]> 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
Use a swig macro for generating the call to the _setCallbackInfo
[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,unsigned 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,unsigned 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,unsigned 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 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 bool val2 ;
30795 int ecode2 = 0 ;
30796 PyObject * obj0 = 0 ;
30797 PyObject * obj1 = 0 ;
30798 char * kwnames[] = {
30799 (char *) "self",(char *) "flag", NULL
30800 };
30801
30802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30804 if (!SWIG_IsOK(res1)) {
30805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30806 }
30807 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30809 if (!SWIG_IsOK(ecode2)) {
30810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30811 }
30812 arg2 = static_cast< bool >(val2);
30813 {
30814 PyThreadState* __tstate = wxPyBeginAllowThreads();
30815 (arg1)->SetUseBestVisual(arg2);
30816 wxPyEndAllowThreads(__tstate);
30817 if (PyErr_Occurred()) SWIG_fail;
30818 }
30819 resultobj = SWIG_Py_Void();
30820 return resultobj;
30821 fail:
30822 return NULL;
30823 }
30824
30825
30826 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30827 PyObject *resultobj = 0;
30828 wxPyApp *arg1 = (wxPyApp *) 0 ;
30829 bool result;
30830 void *argp1 = 0 ;
30831 int res1 = 0 ;
30832 PyObject *swig_obj[1] ;
30833
30834 if (!args) SWIG_fail;
30835 swig_obj[0] = args;
30836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30837 if (!SWIG_IsOK(res1)) {
30838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30839 }
30840 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30841 {
30842 PyThreadState* __tstate = wxPyBeginAllowThreads();
30843 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30844 wxPyEndAllowThreads(__tstate);
30845 if (PyErr_Occurred()) SWIG_fail;
30846 }
30847 {
30848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30849 }
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30857 PyObject *resultobj = 0;
30858 wxPyApp *arg1 = (wxPyApp *) 0 ;
30859 int arg2 ;
30860 void *argp1 = 0 ;
30861 int res1 = 0 ;
30862 int val2 ;
30863 int ecode2 = 0 ;
30864 PyObject * obj0 = 0 ;
30865 PyObject * obj1 = 0 ;
30866 char * kwnames[] = {
30867 (char *) "self",(char *) "mode", NULL
30868 };
30869
30870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30872 if (!SWIG_IsOK(res1)) {
30873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30874 }
30875 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30876 ecode2 = SWIG_AsVal_int(obj1, &val2);
30877 if (!SWIG_IsOK(ecode2)) {
30878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30879 }
30880 arg2 = static_cast< int >(val2);
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 (arg1)->SetPrintMode(arg2);
30884 wxPyEndAllowThreads(__tstate);
30885 if (PyErr_Occurred()) SWIG_fail;
30886 }
30887 resultobj = SWIG_Py_Void();
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxPyApp *arg1 = (wxPyApp *) 0 ;
30897 int result;
30898 void *argp1 = 0 ;
30899 int res1 = 0 ;
30900 PyObject *swig_obj[1] ;
30901
30902 if (!args) SWIG_fail;
30903 swig_obj[0] = args;
30904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30907 }
30908 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 resultobj = SWIG_From_int(static_cast< int >(result));
30916 return resultobj;
30917 fail:
30918 return NULL;
30919 }
30920
30921
30922 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30923 PyObject *resultobj = 0;
30924 wxPyApp *arg1 = (wxPyApp *) 0 ;
30925 int arg2 ;
30926 void *argp1 = 0 ;
30927 int res1 = 0 ;
30928 int val2 ;
30929 int ecode2 = 0 ;
30930 PyObject * obj0 = 0 ;
30931 PyObject * obj1 = 0 ;
30932 char * kwnames[] = {
30933 (char *) "self",(char *) "mode", NULL
30934 };
30935
30936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30938 if (!SWIG_IsOK(res1)) {
30939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30940 }
30941 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30942 ecode2 = SWIG_AsVal_int(obj1, &val2);
30943 if (!SWIG_IsOK(ecode2)) {
30944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30945 }
30946 arg2 = static_cast< int >(val2);
30947 {
30948 PyThreadState* __tstate = wxPyBeginAllowThreads();
30949 (arg1)->SetAssertMode(arg2);
30950 wxPyEndAllowThreads(__tstate);
30951 if (PyErr_Occurred()) SWIG_fail;
30952 }
30953 resultobj = SWIG_Py_Void();
30954 return resultobj;
30955 fail:
30956 return NULL;
30957 }
30958
30959
30960 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30961 PyObject *resultobj = 0;
30962 wxPyApp *arg1 = (wxPyApp *) 0 ;
30963 int result;
30964 void *argp1 = 0 ;
30965 int res1 = 0 ;
30966 PyObject *swig_obj[1] ;
30967
30968 if (!args) SWIG_fail;
30969 swig_obj[0] = args;
30970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30971 if (!SWIG_IsOK(res1)) {
30972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30973 }
30974 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30975 {
30976 PyThreadState* __tstate = wxPyBeginAllowThreads();
30977 result = (int)(arg1)->GetAssertMode();
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 resultobj = SWIG_From_int(static_cast< int >(result));
30982 return resultobj;
30983 fail:
30984 return NULL;
30985 }
30986
30987
30988 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30989 PyObject *resultobj = 0;
30990 bool result;
30991
30992 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
30993 {
30994 PyThreadState* __tstate = wxPyBeginAllowThreads();
30995 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
30996 wxPyEndAllowThreads(__tstate);
30997 if (PyErr_Occurred()) SWIG_fail;
30998 }
30999 {
31000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31001 }
31002 return resultobj;
31003 fail:
31004 return NULL;
31005 }
31006
31007
31008 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31009 PyObject *resultobj = 0;
31010 long result;
31011
31012 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31013 {
31014 PyThreadState* __tstate = wxPyBeginAllowThreads();
31015 result = (long)wxPyApp::GetMacAboutMenuItemId();
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 resultobj = SWIG_From_long(static_cast< long >(result));
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31027 PyObject *resultobj = 0;
31028 long result;
31029
31030 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31031 {
31032 PyThreadState* __tstate = wxPyBeginAllowThreads();
31033 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31034 wxPyEndAllowThreads(__tstate);
31035 if (PyErr_Occurred()) SWIG_fail;
31036 }
31037 resultobj = SWIG_From_long(static_cast< long >(result));
31038 return resultobj;
31039 fail:
31040 return NULL;
31041 }
31042
31043
31044 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31045 PyObject *resultobj = 0;
31046 long result;
31047
31048 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31049 {
31050 PyThreadState* __tstate = wxPyBeginAllowThreads();
31051 result = (long)wxPyApp::GetMacExitMenuItemId();
31052 wxPyEndAllowThreads(__tstate);
31053 if (PyErr_Occurred()) SWIG_fail;
31054 }
31055 resultobj = SWIG_From_long(static_cast< long >(result));
31056 return resultobj;
31057 fail:
31058 return NULL;
31059 }
31060
31061
31062 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31063 PyObject *resultobj = 0;
31064 wxString result;
31065
31066 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31067 {
31068 PyThreadState* __tstate = wxPyBeginAllowThreads();
31069 result = wxPyApp::GetMacHelpMenuTitleName();
31070 wxPyEndAllowThreads(__tstate);
31071 if (PyErr_Occurred()) SWIG_fail;
31072 }
31073 {
31074 #if wxUSE_UNICODE
31075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31076 #else
31077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31078 #endif
31079 }
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj = 0;
31088 bool arg1 ;
31089 bool val1 ;
31090 int ecode1 = 0 ;
31091 PyObject * obj0 = 0 ;
31092 char * kwnames[] = {
31093 (char *) "val", NULL
31094 };
31095
31096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31097 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31098 if (!SWIG_IsOK(ecode1)) {
31099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31100 }
31101 arg1 = static_cast< bool >(val1);
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31105 wxPyEndAllowThreads(__tstate);
31106 if (PyErr_Occurred()) SWIG_fail;
31107 }
31108 resultobj = SWIG_Py_Void();
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31116 PyObject *resultobj = 0;
31117 long arg1 ;
31118 long val1 ;
31119 int ecode1 = 0 ;
31120 PyObject * obj0 = 0 ;
31121 char * kwnames[] = {
31122 (char *) "val", NULL
31123 };
31124
31125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31126 ecode1 = SWIG_AsVal_long(obj0, &val1);
31127 if (!SWIG_IsOK(ecode1)) {
31128 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31129 }
31130 arg1 = static_cast< long >(val1);
31131 {
31132 PyThreadState* __tstate = wxPyBeginAllowThreads();
31133 wxPyApp::SetMacAboutMenuItemId(arg1);
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 resultobj = SWIG_Py_Void();
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31145 PyObject *resultobj = 0;
31146 long arg1 ;
31147 long val1 ;
31148 int ecode1 = 0 ;
31149 PyObject * obj0 = 0 ;
31150 char * kwnames[] = {
31151 (char *) "val", NULL
31152 };
31153
31154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31155 ecode1 = SWIG_AsVal_long(obj0, &val1);
31156 if (!SWIG_IsOK(ecode1)) {
31157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31158 }
31159 arg1 = static_cast< long >(val1);
31160 {
31161 PyThreadState* __tstate = wxPyBeginAllowThreads();
31162 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31163 wxPyEndAllowThreads(__tstate);
31164 if (PyErr_Occurred()) SWIG_fail;
31165 }
31166 resultobj = SWIG_Py_Void();
31167 return resultobj;
31168 fail:
31169 return NULL;
31170 }
31171
31172
31173 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31174 PyObject *resultobj = 0;
31175 long arg1 ;
31176 long val1 ;
31177 int ecode1 = 0 ;
31178 PyObject * obj0 = 0 ;
31179 char * kwnames[] = {
31180 (char *) "val", NULL
31181 };
31182
31183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31184 ecode1 = SWIG_AsVal_long(obj0, &val1);
31185 if (!SWIG_IsOK(ecode1)) {
31186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31187 }
31188 arg1 = static_cast< long >(val1);
31189 {
31190 PyThreadState* __tstate = wxPyBeginAllowThreads();
31191 wxPyApp::SetMacExitMenuItemId(arg1);
31192 wxPyEndAllowThreads(__tstate);
31193 if (PyErr_Occurred()) SWIG_fail;
31194 }
31195 resultobj = SWIG_Py_Void();
31196 return resultobj;
31197 fail:
31198 return NULL;
31199 }
31200
31201
31202 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31203 PyObject *resultobj = 0;
31204 wxString *arg1 = 0 ;
31205 bool temp1 = false ;
31206 PyObject * obj0 = 0 ;
31207 char * kwnames[] = {
31208 (char *) "val", NULL
31209 };
31210
31211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31212 {
31213 arg1 = wxString_in_helper(obj0);
31214 if (arg1 == NULL) SWIG_fail;
31215 temp1 = true;
31216 }
31217 {
31218 PyThreadState* __tstate = wxPyBeginAllowThreads();
31219 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 resultobj = SWIG_Py_Void();
31224 {
31225 if (temp1)
31226 delete arg1;
31227 }
31228 return resultobj;
31229 fail:
31230 {
31231 if (temp1)
31232 delete arg1;
31233 }
31234 return NULL;
31235 }
31236
31237
31238 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31239 PyObject *resultobj = 0;
31240 wxPyApp *arg1 = (wxPyApp *) 0 ;
31241 void *argp1 = 0 ;
31242 int res1 = 0 ;
31243 PyObject *swig_obj[1] ;
31244
31245 if (!args) SWIG_fail;
31246 swig_obj[0] = args;
31247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31248 if (!SWIG_IsOK(res1)) {
31249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31250 }
31251 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31252 {
31253 PyThreadState* __tstate = wxPyBeginAllowThreads();
31254 (arg1)->_BootstrapApp();
31255 wxPyEndAllowThreads(__tstate);
31256 if (PyErr_Occurred()) SWIG_fail;
31257 }
31258 resultobj = SWIG_Py_Void();
31259 return resultobj;
31260 fail:
31261 return NULL;
31262 }
31263
31264
31265 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31266 PyObject *resultobj = 0;
31267 int result;
31268
31269 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31270 {
31271 PyThreadState* __tstate = wxPyBeginAllowThreads();
31272 result = (int)wxPyApp::GetComCtl32Version();
31273 wxPyEndAllowThreads(__tstate);
31274 if (PyErr_Occurred()) SWIG_fail;
31275 }
31276 resultobj = SWIG_From_int(static_cast< int >(result));
31277 return resultobj;
31278 fail:
31279 return NULL;
31280 }
31281
31282
31283 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31284 PyObject *resultobj = 0;
31285 bool result;
31286
31287 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31288 {
31289 PyThreadState* __tstate = wxPyBeginAllowThreads();
31290 result = (bool)wxPyApp_IsDisplayAvailable();
31291 wxPyEndAllowThreads(__tstate);
31292 if (PyErr_Occurred()) SWIG_fail;
31293 }
31294 {
31295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31296 }
31297 return resultobj;
31298 fail:
31299 return NULL;
31300 }
31301
31302
31303 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31304 PyObject *obj;
31305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31306 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31307 return SWIG_Py_Void();
31308 }
31309
31310 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31311 return SWIG_Python_InitShadowInstance(args);
31312 }
31313
31314 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31315 PyObject *resultobj = 0;
31316
31317 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31318 {
31319 PyThreadState* __tstate = wxPyBeginAllowThreads();
31320 wxExit();
31321 wxPyEndAllowThreads(__tstate);
31322 if (PyErr_Occurred()) SWIG_fail;
31323 }
31324 resultobj = SWIG_Py_Void();
31325 return resultobj;
31326 fail:
31327 return NULL;
31328 }
31329
31330
31331 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31332 PyObject *resultobj = 0;
31333 bool result;
31334
31335 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 result = (bool)wxYield();
31339 wxPyEndAllowThreads(__tstate);
31340 if (PyErr_Occurred()) SWIG_fail;
31341 }
31342 {
31343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31344 }
31345 return resultobj;
31346 fail:
31347 return NULL;
31348 }
31349
31350
31351 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31352 PyObject *resultobj = 0;
31353 bool result;
31354
31355 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31356 {
31357 PyThreadState* __tstate = wxPyBeginAllowThreads();
31358 result = (bool)wxYieldIfNeeded();
31359 wxPyEndAllowThreads(__tstate);
31360 if (PyErr_Occurred()) SWIG_fail;
31361 }
31362 {
31363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31364 }
31365 return resultobj;
31366 fail:
31367 return NULL;
31368 }
31369
31370
31371 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31372 PyObject *resultobj = 0;
31373 wxWindow *arg1 = (wxWindow *) NULL ;
31374 bool arg2 = (bool) false ;
31375 bool result;
31376 void *argp1 = 0 ;
31377 int res1 = 0 ;
31378 bool val2 ;
31379 int ecode2 = 0 ;
31380 PyObject * obj0 = 0 ;
31381 PyObject * obj1 = 0 ;
31382 char * kwnames[] = {
31383 (char *) "win",(char *) "onlyIfNeeded", NULL
31384 };
31385
31386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31387 if (obj0) {
31388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31389 if (!SWIG_IsOK(res1)) {
31390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31391 }
31392 arg1 = reinterpret_cast< wxWindow * >(argp1);
31393 }
31394 if (obj1) {
31395 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31396 if (!SWIG_IsOK(ecode2)) {
31397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31398 }
31399 arg2 = static_cast< bool >(val2);
31400 }
31401 {
31402 PyThreadState* __tstate = wxPyBeginAllowThreads();
31403 result = (bool)wxSafeYield(arg1,arg2);
31404 wxPyEndAllowThreads(__tstate);
31405 if (PyErr_Occurred()) SWIG_fail;
31406 }
31407 {
31408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31409 }
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31417 PyObject *resultobj = 0;
31418
31419 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31420 {
31421 PyThreadState* __tstate = wxPyBeginAllowThreads();
31422 wxWakeUpIdle();
31423 wxPyEndAllowThreads(__tstate);
31424 if (PyErr_Occurred()) SWIG_fail;
31425 }
31426 resultobj = SWIG_Py_Void();
31427 return resultobj;
31428 fail:
31429 return NULL;
31430 }
31431
31432
31433 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31434 PyObject *resultobj = 0;
31435 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31436 wxEvent *arg2 = 0 ;
31437 void *argp1 = 0 ;
31438 int res1 = 0 ;
31439 void *argp2 = 0 ;
31440 int res2 = 0 ;
31441 PyObject * obj0 = 0 ;
31442 PyObject * obj1 = 0 ;
31443 char * kwnames[] = {
31444 (char *) "dest",(char *) "event", NULL
31445 };
31446
31447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31449 if (!SWIG_IsOK(res1)) {
31450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31451 }
31452 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31454 if (!SWIG_IsOK(res2)) {
31455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31456 }
31457 if (!argp2) {
31458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31459 }
31460 arg2 = reinterpret_cast< wxEvent * >(argp2);
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 wxPostEvent(arg1,*arg2);
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 resultobj = SWIG_Py_Void();
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31475 PyObject *resultobj = 0;
31476
31477 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31478 {
31479 PyThreadState* __tstate = wxPyBeginAllowThreads();
31480 wxApp_CleanUp();
31481 wxPyEndAllowThreads(__tstate);
31482 if (PyErr_Occurred()) SWIG_fail;
31483 }
31484 resultobj = SWIG_Py_Void();
31485 return resultobj;
31486 fail:
31487 return NULL;
31488 }
31489
31490
31491 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31492 PyObject *resultobj = 0;
31493 wxPyApp *result = 0 ;
31494
31495 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 result = (wxPyApp *)wxPyGetApp();
31499 wxPyEndAllowThreads(__tstate);
31500 if (PyErr_Occurred()) SWIG_fail;
31501 }
31502 {
31503 resultobj = wxPyMake_wxObject(result, 0);
31504 }
31505 return resultobj;
31506 fail:
31507 return NULL;
31508 }
31509
31510
31511 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31512 PyObject *resultobj = 0;
31513 char *arg1 = (char *) 0 ;
31514 int res1 ;
31515 char *buf1 = 0 ;
31516 int alloc1 = 0 ;
31517 PyObject * obj0 = 0 ;
31518 char * kwnames[] = {
31519 (char *) "encoding", NULL
31520 };
31521
31522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31523 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31524 if (!SWIG_IsOK(res1)) {
31525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31526 }
31527 arg1 = buf1;
31528 {
31529 PyThreadState* __tstate = wxPyBeginAllowThreads();
31530 wxSetDefaultPyEncoding((char const *)arg1);
31531 wxPyEndAllowThreads(__tstate);
31532 if (PyErr_Occurred()) SWIG_fail;
31533 }
31534 resultobj = SWIG_Py_Void();
31535 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31536 return resultobj;
31537 fail:
31538 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31539 return NULL;
31540 }
31541
31542
31543 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31544 PyObject *resultobj = 0;
31545 char *result = 0 ;
31546
31547 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31548 {
31549 PyThreadState* __tstate = wxPyBeginAllowThreads();
31550 result = (char *)wxGetDefaultPyEncoding();
31551 wxPyEndAllowThreads(__tstate);
31552 if (PyErr_Occurred()) SWIG_fail;
31553 }
31554 resultobj = SWIG_FromCharPtr(result);
31555 return resultobj;
31556 fail:
31557 return NULL;
31558 }
31559
31560
31561 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31562 PyObject *resultobj = 0;
31563 wxEventLoop *result = 0 ;
31564
31565 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31566 {
31567 PyThreadState* __tstate = wxPyBeginAllowThreads();
31568 result = (wxEventLoop *)new wxEventLoop();
31569 wxPyEndAllowThreads(__tstate);
31570 if (PyErr_Occurred()) SWIG_fail;
31571 }
31572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31573 return resultobj;
31574 fail:
31575 return NULL;
31576 }
31577
31578
31579 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31580 PyObject *resultobj = 0;
31581 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31582 void *argp1 = 0 ;
31583 int res1 = 0 ;
31584 PyObject *swig_obj[1] ;
31585
31586 if (!args) SWIG_fail;
31587 swig_obj[0] = args;
31588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31589 if (!SWIG_IsOK(res1)) {
31590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31591 }
31592 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31593 {
31594 PyThreadState* __tstate = wxPyBeginAllowThreads();
31595 delete arg1;
31596
31597 wxPyEndAllowThreads(__tstate);
31598 if (PyErr_Occurred()) SWIG_fail;
31599 }
31600 resultobj = SWIG_Py_Void();
31601 return resultobj;
31602 fail:
31603 return NULL;
31604 }
31605
31606
31607 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31608 PyObject *resultobj = 0;
31609 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31610 int result;
31611 void *argp1 = 0 ;
31612 int res1 = 0 ;
31613 PyObject *swig_obj[1] ;
31614
31615 if (!args) SWIG_fail;
31616 swig_obj[0] = args;
31617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31618 if (!SWIG_IsOK(res1)) {
31619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31620 }
31621 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31622 {
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 result = (int)(arg1)->Run();
31625 wxPyEndAllowThreads(__tstate);
31626 if (PyErr_Occurred()) SWIG_fail;
31627 }
31628 resultobj = SWIG_From_int(static_cast< int >(result));
31629 return resultobj;
31630 fail:
31631 return NULL;
31632 }
31633
31634
31635 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31636 PyObject *resultobj = 0;
31637 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31638 int arg2 = (int) 0 ;
31639 void *argp1 = 0 ;
31640 int res1 = 0 ;
31641 int val2 ;
31642 int ecode2 = 0 ;
31643 PyObject * obj0 = 0 ;
31644 PyObject * obj1 = 0 ;
31645 char * kwnames[] = {
31646 (char *) "self",(char *) "rc", NULL
31647 };
31648
31649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31651 if (!SWIG_IsOK(res1)) {
31652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31653 }
31654 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31655 if (obj1) {
31656 ecode2 = SWIG_AsVal_int(obj1, &val2);
31657 if (!SWIG_IsOK(ecode2)) {
31658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31659 }
31660 arg2 = static_cast< int >(val2);
31661 }
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 (arg1)->Exit(arg2);
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 resultobj = SWIG_Py_Void();
31669 return resultobj;
31670 fail:
31671 return NULL;
31672 }
31673
31674
31675 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31676 PyObject *resultobj = 0;
31677 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31678 bool result;
31679 void *argp1 = 0 ;
31680 int res1 = 0 ;
31681 PyObject *swig_obj[1] ;
31682
31683 if (!args) SWIG_fail;
31684 swig_obj[0] = args;
31685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31686 if (!SWIG_IsOK(res1)) {
31687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31688 }
31689 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31690 {
31691 PyThreadState* __tstate = wxPyBeginAllowThreads();
31692 result = (bool)((wxEventLoop const *)arg1)->Pending();
31693 wxPyEndAllowThreads(__tstate);
31694 if (PyErr_Occurred()) SWIG_fail;
31695 }
31696 {
31697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31698 }
31699 return resultobj;
31700 fail:
31701 return NULL;
31702 }
31703
31704
31705 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31706 PyObject *resultobj = 0;
31707 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31708 bool result;
31709 void *argp1 = 0 ;
31710 int res1 = 0 ;
31711 PyObject *swig_obj[1] ;
31712
31713 if (!args) SWIG_fail;
31714 swig_obj[0] = args;
31715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31716 if (!SWIG_IsOK(res1)) {
31717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31718 }
31719 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31720 {
31721 PyThreadState* __tstate = wxPyBeginAllowThreads();
31722 result = (bool)(arg1)->Dispatch();
31723 wxPyEndAllowThreads(__tstate);
31724 if (PyErr_Occurred()) SWIG_fail;
31725 }
31726 {
31727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31728 }
31729 return resultobj;
31730 fail:
31731 return NULL;
31732 }
31733
31734
31735 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31736 PyObject *resultobj = 0;
31737 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31738 bool result;
31739 void *argp1 = 0 ;
31740 int res1 = 0 ;
31741 PyObject *swig_obj[1] ;
31742
31743 if (!args) SWIG_fail;
31744 swig_obj[0] = args;
31745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31746 if (!SWIG_IsOK(res1)) {
31747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31748 }
31749 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31750 {
31751 PyThreadState* __tstate = wxPyBeginAllowThreads();
31752 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31753 wxPyEndAllowThreads(__tstate);
31754 if (PyErr_Occurred()) SWIG_fail;
31755 }
31756 {
31757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31758 }
31759 return resultobj;
31760 fail:
31761 return NULL;
31762 }
31763
31764
31765 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31766 PyObject *resultobj = 0;
31767 wxEventLoop *result = 0 ;
31768
31769 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31770 {
31771 PyThreadState* __tstate = wxPyBeginAllowThreads();
31772 result = (wxEventLoop *)wxEventLoop::GetActive();
31773 wxPyEndAllowThreads(__tstate);
31774 if (PyErr_Occurred()) SWIG_fail;
31775 }
31776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31777 return resultobj;
31778 fail:
31779 return NULL;
31780 }
31781
31782
31783 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31784 PyObject *resultobj = 0;
31785 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31786 void *argp1 = 0 ;
31787 int res1 = 0 ;
31788 PyObject * obj0 = 0 ;
31789 char * kwnames[] = {
31790 (char *) "loop", NULL
31791 };
31792
31793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31795 if (!SWIG_IsOK(res1)) {
31796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31797 }
31798 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31799 {
31800 PyThreadState* __tstate = wxPyBeginAllowThreads();
31801 wxEventLoop::SetActive(arg1);
31802 wxPyEndAllowThreads(__tstate);
31803 if (PyErr_Occurred()) SWIG_fail;
31804 }
31805 resultobj = SWIG_Py_Void();
31806 return resultobj;
31807 fail:
31808 return NULL;
31809 }
31810
31811
31812 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31813 PyObject *obj;
31814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31815 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31816 return SWIG_Py_Void();
31817 }
31818
31819 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31820 return SWIG_Python_InitShadowInstance(args);
31821 }
31822
31823 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31824 PyObject *resultobj = 0;
31825 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31826 wxEventLoopActivator *result = 0 ;
31827 void *argp1 = 0 ;
31828 int res1 = 0 ;
31829 PyObject * obj0 = 0 ;
31830 char * kwnames[] = {
31831 (char *) "evtLoop", NULL
31832 };
31833
31834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31836 if (!SWIG_IsOK(res1)) {
31837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31838 }
31839 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31840 {
31841 PyThreadState* __tstate = wxPyBeginAllowThreads();
31842 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31843 wxPyEndAllowThreads(__tstate);
31844 if (PyErr_Occurred()) SWIG_fail;
31845 }
31846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31847 return resultobj;
31848 fail:
31849 return NULL;
31850 }
31851
31852
31853 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31854 PyObject *resultobj = 0;
31855 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31856 void *argp1 = 0 ;
31857 int res1 = 0 ;
31858 PyObject *swig_obj[1] ;
31859
31860 if (!args) SWIG_fail;
31861 swig_obj[0] = args;
31862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31863 if (!SWIG_IsOK(res1)) {
31864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31865 }
31866 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 delete arg1;
31870
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_Py_Void();
31875 return resultobj;
31876 fail:
31877 return NULL;
31878 }
31879
31880
31881 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31882 PyObject *obj;
31883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31884 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31885 return SWIG_Py_Void();
31886 }
31887
31888 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31889 return SWIG_Python_InitShadowInstance(args);
31890 }
31891
31892 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31893 PyObject *resultobj = 0;
31894 int arg1 = (int) 0 ;
31895 int arg2 = (int) 0 ;
31896 int arg3 = (int) 0 ;
31897 wxAcceleratorEntry *result = 0 ;
31898 int val1 ;
31899 int ecode1 = 0 ;
31900 int val2 ;
31901 int ecode2 = 0 ;
31902 int val3 ;
31903 int ecode3 = 0 ;
31904 PyObject * obj0 = 0 ;
31905 PyObject * obj1 = 0 ;
31906 PyObject * obj2 = 0 ;
31907 char * kwnames[] = {
31908 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31909 };
31910
31911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31912 if (obj0) {
31913 ecode1 = SWIG_AsVal_int(obj0, &val1);
31914 if (!SWIG_IsOK(ecode1)) {
31915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31916 }
31917 arg1 = static_cast< int >(val1);
31918 }
31919 if (obj1) {
31920 ecode2 = SWIG_AsVal_int(obj1, &val2);
31921 if (!SWIG_IsOK(ecode2)) {
31922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31923 }
31924 arg2 = static_cast< int >(val2);
31925 }
31926 if (obj2) {
31927 ecode3 = SWIG_AsVal_int(obj2, &val3);
31928 if (!SWIG_IsOK(ecode3)) {
31929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31930 }
31931 arg3 = static_cast< int >(val3);
31932 }
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31940 return resultobj;
31941 fail:
31942 return NULL;
31943 }
31944
31945
31946 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31947 PyObject *resultobj = 0;
31948 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31949 void *argp1 = 0 ;
31950 int res1 = 0 ;
31951 PyObject *swig_obj[1] ;
31952
31953 if (!args) SWIG_fail;
31954 swig_obj[0] = args;
31955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31958 }
31959 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 delete arg1;
31963
31964 wxPyEndAllowThreads(__tstate);
31965 if (PyErr_Occurred()) SWIG_fail;
31966 }
31967 resultobj = SWIG_Py_Void();
31968 return resultobj;
31969 fail:
31970 return NULL;
31971 }
31972
31973
31974 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31975 PyObject *resultobj = 0;
31976 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31977 int arg2 ;
31978 int arg3 ;
31979 int arg4 ;
31980 void *argp1 = 0 ;
31981 int res1 = 0 ;
31982 int val2 ;
31983 int ecode2 = 0 ;
31984 int val3 ;
31985 int ecode3 = 0 ;
31986 int val4 ;
31987 int ecode4 = 0 ;
31988 PyObject * obj0 = 0 ;
31989 PyObject * obj1 = 0 ;
31990 PyObject * obj2 = 0 ;
31991 PyObject * obj3 = 0 ;
31992 char * kwnames[] = {
31993 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
31994 };
31995
31996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
31998 if (!SWIG_IsOK(res1)) {
31999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32000 }
32001 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32002 ecode2 = SWIG_AsVal_int(obj1, &val2);
32003 if (!SWIG_IsOK(ecode2)) {
32004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32005 }
32006 arg2 = static_cast< int >(val2);
32007 ecode3 = SWIG_AsVal_int(obj2, &val3);
32008 if (!SWIG_IsOK(ecode3)) {
32009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32010 }
32011 arg3 = static_cast< int >(val3);
32012 ecode4 = SWIG_AsVal_int(obj3, &val4);
32013 if (!SWIG_IsOK(ecode4)) {
32014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32015 }
32016 arg4 = static_cast< int >(val4);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 (arg1)->Set(arg2,arg3,arg4);
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_Py_Void();
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32031 PyObject *resultobj = 0;
32032 wxString *arg1 = 0 ;
32033 wxAcceleratorEntry *result = 0 ;
32034 bool temp1 = false ;
32035 PyObject * obj0 = 0 ;
32036 char * kwnames[] = {
32037 (char *) "str", NULL
32038 };
32039
32040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32041 {
32042 arg1 = wxString_in_helper(obj0);
32043 if (arg1 == NULL) SWIG_fail;
32044 temp1 = true;
32045 }
32046 {
32047 PyThreadState* __tstate = wxPyBeginAllowThreads();
32048 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32049 wxPyEndAllowThreads(__tstate);
32050 if (PyErr_Occurred()) SWIG_fail;
32051 }
32052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32053 {
32054 if (temp1)
32055 delete arg1;
32056 }
32057 return resultobj;
32058 fail:
32059 {
32060 if (temp1)
32061 delete arg1;
32062 }
32063 return NULL;
32064 }
32065
32066
32067 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32068 PyObject *resultobj = 0;
32069 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32070 int result;
32071 void *argp1 = 0 ;
32072 int res1 = 0 ;
32073 PyObject *swig_obj[1] ;
32074
32075 if (!args) SWIG_fail;
32076 swig_obj[0] = args;
32077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32078 if (!SWIG_IsOK(res1)) {
32079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32080 }
32081 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32082 {
32083 PyThreadState* __tstate = wxPyBeginAllowThreads();
32084 result = (int)(arg1)->GetFlags();
32085 wxPyEndAllowThreads(__tstate);
32086 if (PyErr_Occurred()) SWIG_fail;
32087 }
32088 resultobj = SWIG_From_int(static_cast< int >(result));
32089 return resultobj;
32090 fail:
32091 return NULL;
32092 }
32093
32094
32095 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32096 PyObject *resultobj = 0;
32097 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32098 int result;
32099 void *argp1 = 0 ;
32100 int res1 = 0 ;
32101 PyObject *swig_obj[1] ;
32102
32103 if (!args) SWIG_fail;
32104 swig_obj[0] = args;
32105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32106 if (!SWIG_IsOK(res1)) {
32107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32108 }
32109 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32110 {
32111 PyThreadState* __tstate = wxPyBeginAllowThreads();
32112 result = (int)(arg1)->GetKeyCode();
32113 wxPyEndAllowThreads(__tstate);
32114 if (PyErr_Occurred()) SWIG_fail;
32115 }
32116 resultobj = SWIG_From_int(static_cast< int >(result));
32117 return resultobj;
32118 fail:
32119 return NULL;
32120 }
32121
32122
32123 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32124 PyObject *resultobj = 0;
32125 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32126 int result;
32127 void *argp1 = 0 ;
32128 int res1 = 0 ;
32129 PyObject *swig_obj[1] ;
32130
32131 if (!args) SWIG_fail;
32132 swig_obj[0] = args;
32133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32134 if (!SWIG_IsOK(res1)) {
32135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32136 }
32137 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32138 {
32139 PyThreadState* __tstate = wxPyBeginAllowThreads();
32140 result = (int)(arg1)->GetCommand();
32141 wxPyEndAllowThreads(__tstate);
32142 if (PyErr_Occurred()) SWIG_fail;
32143 }
32144 resultobj = SWIG_From_int(static_cast< int >(result));
32145 return resultobj;
32146 fail:
32147 return NULL;
32148 }
32149
32150
32151 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32152 PyObject *resultobj = 0;
32153 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32154 bool result;
32155 void *argp1 = 0 ;
32156 int res1 = 0 ;
32157 PyObject *swig_obj[1] ;
32158
32159 if (!args) SWIG_fail;
32160 swig_obj[0] = args;
32161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32162 if (!SWIG_IsOK(res1)) {
32163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32164 }
32165 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32169 wxPyEndAllowThreads(__tstate);
32170 if (PyErr_Occurred()) SWIG_fail;
32171 }
32172 {
32173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32174 }
32175 return resultobj;
32176 fail:
32177 return NULL;
32178 }
32179
32180
32181 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32182 PyObject *resultobj = 0;
32183 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32184 wxString result;
32185 void *argp1 = 0 ;
32186 int res1 = 0 ;
32187 PyObject *swig_obj[1] ;
32188
32189 if (!args) SWIG_fail;
32190 swig_obj[0] = args;
32191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32192 if (!SWIG_IsOK(res1)) {
32193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32194 }
32195 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32196 {
32197 PyThreadState* __tstate = wxPyBeginAllowThreads();
32198 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32199 wxPyEndAllowThreads(__tstate);
32200 if (PyErr_Occurred()) SWIG_fail;
32201 }
32202 {
32203 #if wxUSE_UNICODE
32204 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32205 #else
32206 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32207 #endif
32208 }
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32216 PyObject *resultobj = 0;
32217 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32218 wxString *arg2 = 0 ;
32219 bool result;
32220 void *argp1 = 0 ;
32221 int res1 = 0 ;
32222 bool temp2 = false ;
32223 PyObject * obj0 = 0 ;
32224 PyObject * obj1 = 0 ;
32225 char * kwnames[] = {
32226 (char *) "self",(char *) "str", NULL
32227 };
32228
32229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32231 if (!SWIG_IsOK(res1)) {
32232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32233 }
32234 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32235 {
32236 arg2 = wxString_in_helper(obj1);
32237 if (arg2 == NULL) SWIG_fail;
32238 temp2 = true;
32239 }
32240 {
32241 PyThreadState* __tstate = wxPyBeginAllowThreads();
32242 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32243 wxPyEndAllowThreads(__tstate);
32244 if (PyErr_Occurred()) SWIG_fail;
32245 }
32246 {
32247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32248 }
32249 {
32250 if (temp2)
32251 delete arg2;
32252 }
32253 return resultobj;
32254 fail:
32255 {
32256 if (temp2)
32257 delete arg2;
32258 }
32259 return NULL;
32260 }
32261
32262
32263 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32264 PyObject *obj;
32265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32266 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32267 return SWIG_Py_Void();
32268 }
32269
32270 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32271 return SWIG_Python_InitShadowInstance(args);
32272 }
32273
32274 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32275 PyObject *resultobj = 0;
32276 int arg1 ;
32277 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32278 wxAcceleratorTable *result = 0 ;
32279 PyObject * obj0 = 0 ;
32280 char * kwnames[] = {
32281 (char *) "n", NULL
32282 };
32283
32284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32285 {
32286 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32287 if (arg2) arg1 = PyList_Size(obj0);
32288 else arg1 = 0;
32289 }
32290 {
32291 PyThreadState* __tstate = wxPyBeginAllowThreads();
32292 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32293 wxPyEndAllowThreads(__tstate);
32294 if (PyErr_Occurred()) SWIG_fail;
32295 }
32296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32297 return resultobj;
32298 fail:
32299 return NULL;
32300 }
32301
32302
32303 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32304 PyObject *resultobj = 0;
32305 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32306 void *argp1 = 0 ;
32307 int res1 = 0 ;
32308 PyObject *swig_obj[1] ;
32309
32310 if (!args) SWIG_fail;
32311 swig_obj[0] = args;
32312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32313 if (!SWIG_IsOK(res1)) {
32314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32315 }
32316 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 delete arg1;
32320
32321 wxPyEndAllowThreads(__tstate);
32322 if (PyErr_Occurred()) SWIG_fail;
32323 }
32324 resultobj = SWIG_Py_Void();
32325 return resultobj;
32326 fail:
32327 return NULL;
32328 }
32329
32330
32331 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32332 PyObject *resultobj = 0;
32333 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32334 bool result;
32335 void *argp1 = 0 ;
32336 int res1 = 0 ;
32337 PyObject *swig_obj[1] ;
32338
32339 if (!args) SWIG_fail;
32340 swig_obj[0] = args;
32341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32342 if (!SWIG_IsOK(res1)) {
32343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32344 }
32345 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32346 {
32347 PyThreadState* __tstate = wxPyBeginAllowThreads();
32348 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32349 wxPyEndAllowThreads(__tstate);
32350 if (PyErr_Occurred()) SWIG_fail;
32351 }
32352 {
32353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32354 }
32355 return resultobj;
32356 fail:
32357 return NULL;
32358 }
32359
32360
32361 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32362 PyObject *obj;
32363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32364 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32365 return SWIG_Py_Void();
32366 }
32367
32368 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32369 return SWIG_Python_InitShadowInstance(args);
32370 }
32371
32372 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32373 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32374 return 1;
32375 }
32376
32377
32378 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32379 PyObject *pyobj = 0;
32380
32381 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32382 return pyobj;
32383 }
32384
32385
32386 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32387 PyObject *resultobj = 0;
32388 wxString *arg1 = 0 ;
32389 wxAcceleratorEntry *result = 0 ;
32390 bool temp1 = false ;
32391 PyObject * obj0 = 0 ;
32392 char * kwnames[] = {
32393 (char *) "label", NULL
32394 };
32395
32396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32397 {
32398 arg1 = wxString_in_helper(obj0);
32399 if (arg1 == NULL) SWIG_fail;
32400 temp1 = true;
32401 }
32402 {
32403 PyThreadState* __tstate = wxPyBeginAllowThreads();
32404 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32405 wxPyEndAllowThreads(__tstate);
32406 if (PyErr_Occurred()) SWIG_fail;
32407 }
32408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32409 {
32410 if (temp1)
32411 delete arg1;
32412 }
32413 return resultobj;
32414 fail:
32415 {
32416 if (temp1)
32417 delete arg1;
32418 }
32419 return NULL;
32420 }
32421
32422
32423 SWIGINTERN int PanelNameStr_set(PyObject *) {
32424 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32425 return 1;
32426 }
32427
32428
32429 SWIGINTERN PyObject *PanelNameStr_get(void) {
32430 PyObject *pyobj = 0;
32431
32432 {
32433 #if wxUSE_UNICODE
32434 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32435 #else
32436 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32437 #endif
32438 }
32439 return pyobj;
32440 }
32441
32442
32443 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32444 PyObject *resultobj = 0;
32445 wxVisualAttributes *result = 0 ;
32446
32447 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32448 {
32449 PyThreadState* __tstate = wxPyBeginAllowThreads();
32450 result = (wxVisualAttributes *)new_wxVisualAttributes();
32451 wxPyEndAllowThreads(__tstate);
32452 if (PyErr_Occurred()) SWIG_fail;
32453 }
32454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32455 return resultobj;
32456 fail:
32457 return NULL;
32458 }
32459
32460
32461 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32462 PyObject *resultobj = 0;
32463 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32464 void *argp1 = 0 ;
32465 int res1 = 0 ;
32466 PyObject *swig_obj[1] ;
32467
32468 if (!args) SWIG_fail;
32469 swig_obj[0] = args;
32470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32471 if (!SWIG_IsOK(res1)) {
32472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32473 }
32474 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32475 {
32476 PyThreadState* __tstate = wxPyBeginAllowThreads();
32477 delete_wxVisualAttributes(arg1);
32478
32479 wxPyEndAllowThreads(__tstate);
32480 if (PyErr_Occurred()) SWIG_fail;
32481 }
32482 resultobj = SWIG_Py_Void();
32483 return resultobj;
32484 fail:
32485 return NULL;
32486 }
32487
32488
32489 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32490 PyObject *resultobj = 0;
32491 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32492 wxFont *arg2 = (wxFont *) 0 ;
32493 void *argp1 = 0 ;
32494 int res1 = 0 ;
32495 void *argp2 = 0 ;
32496 int res2 = 0 ;
32497 PyObject *swig_obj[2] ;
32498
32499 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32501 if (!SWIG_IsOK(res1)) {
32502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32503 }
32504 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32505 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32506 if (!SWIG_IsOK(res2)) {
32507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32508 }
32509 arg2 = reinterpret_cast< wxFont * >(argp2);
32510 if (arg1) (arg1)->font = *arg2;
32511
32512 resultobj = SWIG_Py_Void();
32513 return resultobj;
32514 fail:
32515 return NULL;
32516 }
32517
32518
32519 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32520 PyObject *resultobj = 0;
32521 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32522 wxFont *result = 0 ;
32523 void *argp1 = 0 ;
32524 int res1 = 0 ;
32525 PyObject *swig_obj[1] ;
32526
32527 if (!args) SWIG_fail;
32528 swig_obj[0] = args;
32529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32530 if (!SWIG_IsOK(res1)) {
32531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32532 }
32533 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32534 result = (wxFont *)& ((arg1)->font);
32535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32536 return resultobj;
32537 fail:
32538 return NULL;
32539 }
32540
32541
32542 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32543 PyObject *resultobj = 0;
32544 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32545 wxColour *arg2 = (wxColour *) 0 ;
32546 void *argp1 = 0 ;
32547 int res1 = 0 ;
32548 void *argp2 = 0 ;
32549 int res2 = 0 ;
32550 PyObject *swig_obj[2] ;
32551
32552 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32554 if (!SWIG_IsOK(res1)) {
32555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32556 }
32557 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32558 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32559 if (!SWIG_IsOK(res2)) {
32560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32561 }
32562 arg2 = reinterpret_cast< wxColour * >(argp2);
32563 if (arg1) (arg1)->colFg = *arg2;
32564
32565 resultobj = SWIG_Py_Void();
32566 return resultobj;
32567 fail:
32568 return NULL;
32569 }
32570
32571
32572 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32573 PyObject *resultobj = 0;
32574 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32575 wxColour *result = 0 ;
32576 void *argp1 = 0 ;
32577 int res1 = 0 ;
32578 PyObject *swig_obj[1] ;
32579
32580 if (!args) SWIG_fail;
32581 swig_obj[0] = args;
32582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32583 if (!SWIG_IsOK(res1)) {
32584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32585 }
32586 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32587 result = (wxColour *)& ((arg1)->colFg);
32588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32589 return resultobj;
32590 fail:
32591 return NULL;
32592 }
32593
32594
32595 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32596 PyObject *resultobj = 0;
32597 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32598 wxColour *arg2 = (wxColour *) 0 ;
32599 void *argp1 = 0 ;
32600 int res1 = 0 ;
32601 void *argp2 = 0 ;
32602 int res2 = 0 ;
32603 PyObject *swig_obj[2] ;
32604
32605 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32607 if (!SWIG_IsOK(res1)) {
32608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32609 }
32610 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32611 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32612 if (!SWIG_IsOK(res2)) {
32613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32614 }
32615 arg2 = reinterpret_cast< wxColour * >(argp2);
32616 if (arg1) (arg1)->colBg = *arg2;
32617
32618 resultobj = SWIG_Py_Void();
32619 return resultobj;
32620 fail:
32621 return NULL;
32622 }
32623
32624
32625 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32626 PyObject *resultobj = 0;
32627 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32628 wxColour *result = 0 ;
32629 void *argp1 = 0 ;
32630 int res1 = 0 ;
32631 PyObject *swig_obj[1] ;
32632
32633 if (!args) SWIG_fail;
32634 swig_obj[0] = args;
32635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32636 if (!SWIG_IsOK(res1)) {
32637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32638 }
32639 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32640 result = (wxColour *)& ((arg1)->colBg);
32641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32642 return resultobj;
32643 fail:
32644 return NULL;
32645 }
32646
32647
32648 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32649 PyObject *obj;
32650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32651 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32652 return SWIG_Py_Void();
32653 }
32654
32655 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32656 return SWIG_Python_InitShadowInstance(args);
32657 }
32658
32659 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32660 PyObject *resultobj = 0;
32661 wxWindow *arg1 = (wxWindow *) 0 ;
32662 int arg2 = (int) (int)-1 ;
32663 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32664 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32665 wxSize const &arg4_defvalue = wxDefaultSize ;
32666 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32667 long arg5 = (long) 0 ;
32668 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32669 wxString *arg6 = (wxString *) &arg6_defvalue ;
32670 wxWindow *result = 0 ;
32671 void *argp1 = 0 ;
32672 int res1 = 0 ;
32673 int val2 ;
32674 int ecode2 = 0 ;
32675 wxPoint temp3 ;
32676 wxSize temp4 ;
32677 long val5 ;
32678 int ecode5 = 0 ;
32679 bool temp6 = false ;
32680 PyObject * obj0 = 0 ;
32681 PyObject * obj1 = 0 ;
32682 PyObject * obj2 = 0 ;
32683 PyObject * obj3 = 0 ;
32684 PyObject * obj4 = 0 ;
32685 PyObject * obj5 = 0 ;
32686 char * kwnames[] = {
32687 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32688 };
32689
32690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32692 if (!SWIG_IsOK(res1)) {
32693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32694 }
32695 arg1 = reinterpret_cast< wxWindow * >(argp1);
32696 if (obj1) {
32697 ecode2 = SWIG_AsVal_int(obj1, &val2);
32698 if (!SWIG_IsOK(ecode2)) {
32699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32700 }
32701 arg2 = static_cast< int >(val2);
32702 }
32703 if (obj2) {
32704 {
32705 arg3 = &temp3;
32706 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32707 }
32708 }
32709 if (obj3) {
32710 {
32711 arg4 = &temp4;
32712 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32713 }
32714 }
32715 if (obj4) {
32716 ecode5 = SWIG_AsVal_long(obj4, &val5);
32717 if (!SWIG_IsOK(ecode5)) {
32718 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32719 }
32720 arg5 = static_cast< long >(val5);
32721 }
32722 if (obj5) {
32723 {
32724 arg6 = wxString_in_helper(obj5);
32725 if (arg6 == NULL) SWIG_fail;
32726 temp6 = true;
32727 }
32728 }
32729 {
32730 if (!wxPyCheckForApp()) SWIG_fail;
32731 PyThreadState* __tstate = wxPyBeginAllowThreads();
32732 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32733 wxPyEndAllowThreads(__tstate);
32734 if (PyErr_Occurred()) SWIG_fail;
32735 }
32736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32737 {
32738 if (temp6)
32739 delete arg6;
32740 }
32741 return resultobj;
32742 fail:
32743 {
32744 if (temp6)
32745 delete arg6;
32746 }
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32752 PyObject *resultobj = 0;
32753 wxWindow *result = 0 ;
32754
32755 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32756 {
32757 if (!wxPyCheckForApp()) SWIG_fail;
32758 PyThreadState* __tstate = wxPyBeginAllowThreads();
32759 result = (wxWindow *)new wxWindow();
32760 wxPyEndAllowThreads(__tstate);
32761 if (PyErr_Occurred()) SWIG_fail;
32762 }
32763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32764 return resultobj;
32765 fail:
32766 return NULL;
32767 }
32768
32769
32770 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32771 PyObject *resultobj = 0;
32772 wxWindow *arg1 = (wxWindow *) 0 ;
32773 wxWindow *arg2 = (wxWindow *) 0 ;
32774 int arg3 = (int) (int)-1 ;
32775 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32776 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32777 wxSize const &arg5_defvalue = wxDefaultSize ;
32778 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32779 long arg6 = (long) 0 ;
32780 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32781 wxString *arg7 = (wxString *) &arg7_defvalue ;
32782 bool result;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 void *argp2 = 0 ;
32786 int res2 = 0 ;
32787 int val3 ;
32788 int ecode3 = 0 ;
32789 wxPoint temp4 ;
32790 wxSize temp5 ;
32791 long val6 ;
32792 int ecode6 = 0 ;
32793 bool temp7 = false ;
32794 PyObject * obj0 = 0 ;
32795 PyObject * obj1 = 0 ;
32796 PyObject * obj2 = 0 ;
32797 PyObject * obj3 = 0 ;
32798 PyObject * obj4 = 0 ;
32799 PyObject * obj5 = 0 ;
32800 PyObject * obj6 = 0 ;
32801 char * kwnames[] = {
32802 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32803 };
32804
32805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32807 if (!SWIG_IsOK(res1)) {
32808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32809 }
32810 arg1 = reinterpret_cast< wxWindow * >(argp1);
32811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32812 if (!SWIG_IsOK(res2)) {
32813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32814 }
32815 arg2 = reinterpret_cast< wxWindow * >(argp2);
32816 if (obj2) {
32817 ecode3 = SWIG_AsVal_int(obj2, &val3);
32818 if (!SWIG_IsOK(ecode3)) {
32819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32820 }
32821 arg3 = static_cast< int >(val3);
32822 }
32823 if (obj3) {
32824 {
32825 arg4 = &temp4;
32826 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32827 }
32828 }
32829 if (obj4) {
32830 {
32831 arg5 = &temp5;
32832 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32833 }
32834 }
32835 if (obj5) {
32836 ecode6 = SWIG_AsVal_long(obj5, &val6);
32837 if (!SWIG_IsOK(ecode6)) {
32838 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32839 }
32840 arg6 = static_cast< long >(val6);
32841 }
32842 if (obj6) {
32843 {
32844 arg7 = wxString_in_helper(obj6);
32845 if (arg7 == NULL) SWIG_fail;
32846 temp7 = true;
32847 }
32848 }
32849 {
32850 PyThreadState* __tstate = wxPyBeginAllowThreads();
32851 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32852 wxPyEndAllowThreads(__tstate);
32853 if (PyErr_Occurred()) SWIG_fail;
32854 }
32855 {
32856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32857 }
32858 {
32859 if (temp7)
32860 delete arg7;
32861 }
32862 return resultobj;
32863 fail:
32864 {
32865 if (temp7)
32866 delete arg7;
32867 }
32868 return NULL;
32869 }
32870
32871
32872 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32873 PyObject *resultobj = 0;
32874 wxWindow *arg1 = (wxWindow *) 0 ;
32875 bool arg2 = (bool) false ;
32876 bool result;
32877 void *argp1 = 0 ;
32878 int res1 = 0 ;
32879 bool val2 ;
32880 int ecode2 = 0 ;
32881 PyObject * obj0 = 0 ;
32882 PyObject * obj1 = 0 ;
32883 char * kwnames[] = {
32884 (char *) "self",(char *) "force", NULL
32885 };
32886
32887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32889 if (!SWIG_IsOK(res1)) {
32890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32891 }
32892 arg1 = reinterpret_cast< wxWindow * >(argp1);
32893 if (obj1) {
32894 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32895 if (!SWIG_IsOK(ecode2)) {
32896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32897 }
32898 arg2 = static_cast< bool >(val2);
32899 }
32900 {
32901 PyThreadState* __tstate = wxPyBeginAllowThreads();
32902 result = (bool)(arg1)->Close(arg2);
32903 wxPyEndAllowThreads(__tstate);
32904 if (PyErr_Occurred()) SWIG_fail;
32905 }
32906 {
32907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32908 }
32909 return resultobj;
32910 fail:
32911 return NULL;
32912 }
32913
32914
32915 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32916 PyObject *resultobj = 0;
32917 wxWindow *arg1 = (wxWindow *) 0 ;
32918 bool result;
32919 void *argp1 = 0 ;
32920 int res1 = 0 ;
32921 PyObject *swig_obj[1] ;
32922
32923 if (!args) SWIG_fail;
32924 swig_obj[0] = args;
32925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32926 if (!SWIG_IsOK(res1)) {
32927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32928 }
32929 arg1 = reinterpret_cast< wxWindow * >(argp1);
32930 {
32931 PyThreadState* __tstate = wxPyBeginAllowThreads();
32932 result = (bool)(arg1)->Destroy();
32933 wxPyEndAllowThreads(__tstate);
32934 if (PyErr_Occurred()) SWIG_fail;
32935 }
32936 {
32937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32938 }
32939 return resultobj;
32940 fail:
32941 return NULL;
32942 }
32943
32944
32945 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32946 PyObject *resultobj = 0;
32947 wxWindow *arg1 = (wxWindow *) 0 ;
32948 bool result;
32949 void *argp1 = 0 ;
32950 int res1 = 0 ;
32951 PyObject *swig_obj[1] ;
32952
32953 if (!args) SWIG_fail;
32954 swig_obj[0] = args;
32955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32956 if (!SWIG_IsOK(res1)) {
32957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32958 }
32959 arg1 = reinterpret_cast< wxWindow * >(argp1);
32960 {
32961 PyThreadState* __tstate = wxPyBeginAllowThreads();
32962 result = (bool)(arg1)->DestroyChildren();
32963 wxPyEndAllowThreads(__tstate);
32964 if (PyErr_Occurred()) SWIG_fail;
32965 }
32966 {
32967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32968 }
32969 return resultobj;
32970 fail:
32971 return NULL;
32972 }
32973
32974
32975 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32976 PyObject *resultobj = 0;
32977 wxWindow *arg1 = (wxWindow *) 0 ;
32978 bool result;
32979 void *argp1 = 0 ;
32980 int res1 = 0 ;
32981 PyObject *swig_obj[1] ;
32982
32983 if (!args) SWIG_fail;
32984 swig_obj[0] = args;
32985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32986 if (!SWIG_IsOK(res1)) {
32987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
32988 }
32989 arg1 = reinterpret_cast< wxWindow * >(argp1);
32990 {
32991 PyThreadState* __tstate = wxPyBeginAllowThreads();
32992 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
32993 wxPyEndAllowThreads(__tstate);
32994 if (PyErr_Occurred()) SWIG_fail;
32995 }
32996 {
32997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32998 }
32999 return resultobj;
33000 fail:
33001 return NULL;
33002 }
33003
33004
33005 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33006 PyObject *resultobj = 0;
33007 wxWindow *arg1 = (wxWindow *) 0 ;
33008 wxString *arg2 = 0 ;
33009 void *argp1 = 0 ;
33010 int res1 = 0 ;
33011 bool temp2 = false ;
33012 PyObject * obj0 = 0 ;
33013 PyObject * obj1 = 0 ;
33014 char * kwnames[] = {
33015 (char *) "self",(char *) "label", NULL
33016 };
33017
33018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33020 if (!SWIG_IsOK(res1)) {
33021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33022 }
33023 arg1 = reinterpret_cast< wxWindow * >(argp1);
33024 {
33025 arg2 = wxString_in_helper(obj1);
33026 if (arg2 == NULL) SWIG_fail;
33027 temp2 = true;
33028 }
33029 {
33030 PyThreadState* __tstate = wxPyBeginAllowThreads();
33031 (arg1)->SetLabel((wxString const &)*arg2);
33032 wxPyEndAllowThreads(__tstate);
33033 if (PyErr_Occurred()) SWIG_fail;
33034 }
33035 resultobj = SWIG_Py_Void();
33036 {
33037 if (temp2)
33038 delete arg2;
33039 }
33040 return resultobj;
33041 fail:
33042 {
33043 if (temp2)
33044 delete arg2;
33045 }
33046 return NULL;
33047 }
33048
33049
33050 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33051 PyObject *resultobj = 0;
33052 wxWindow *arg1 = (wxWindow *) 0 ;
33053 wxString result;
33054 void *argp1 = 0 ;
33055 int res1 = 0 ;
33056 PyObject *swig_obj[1] ;
33057
33058 if (!args) SWIG_fail;
33059 swig_obj[0] = args;
33060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33061 if (!SWIG_IsOK(res1)) {
33062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33063 }
33064 arg1 = reinterpret_cast< wxWindow * >(argp1);
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 result = ((wxWindow const *)arg1)->GetLabel();
33068 wxPyEndAllowThreads(__tstate);
33069 if (PyErr_Occurred()) SWIG_fail;
33070 }
33071 {
33072 #if wxUSE_UNICODE
33073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33074 #else
33075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33076 #endif
33077 }
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33085 PyObject *resultobj = 0;
33086 wxWindow *arg1 = (wxWindow *) 0 ;
33087 wxString *arg2 = 0 ;
33088 void *argp1 = 0 ;
33089 int res1 = 0 ;
33090 bool temp2 = false ;
33091 PyObject * obj0 = 0 ;
33092 PyObject * obj1 = 0 ;
33093 char * kwnames[] = {
33094 (char *) "self",(char *) "name", NULL
33095 };
33096
33097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33099 if (!SWIG_IsOK(res1)) {
33100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33101 }
33102 arg1 = reinterpret_cast< wxWindow * >(argp1);
33103 {
33104 arg2 = wxString_in_helper(obj1);
33105 if (arg2 == NULL) SWIG_fail;
33106 temp2 = true;
33107 }
33108 {
33109 PyThreadState* __tstate = wxPyBeginAllowThreads();
33110 (arg1)->SetName((wxString const &)*arg2);
33111 wxPyEndAllowThreads(__tstate);
33112 if (PyErr_Occurred()) SWIG_fail;
33113 }
33114 resultobj = SWIG_Py_Void();
33115 {
33116 if (temp2)
33117 delete arg2;
33118 }
33119 return resultobj;
33120 fail:
33121 {
33122 if (temp2)
33123 delete arg2;
33124 }
33125 return NULL;
33126 }
33127
33128
33129 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33130 PyObject *resultobj = 0;
33131 wxWindow *arg1 = (wxWindow *) 0 ;
33132 wxString result;
33133 void *argp1 = 0 ;
33134 int res1 = 0 ;
33135 PyObject *swig_obj[1] ;
33136
33137 if (!args) SWIG_fail;
33138 swig_obj[0] = args;
33139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33140 if (!SWIG_IsOK(res1)) {
33141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33142 }
33143 arg1 = reinterpret_cast< wxWindow * >(argp1);
33144 {
33145 PyThreadState* __tstate = wxPyBeginAllowThreads();
33146 result = ((wxWindow const *)arg1)->GetName();
33147 wxPyEndAllowThreads(__tstate);
33148 if (PyErr_Occurred()) SWIG_fail;
33149 }
33150 {
33151 #if wxUSE_UNICODE
33152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33153 #else
33154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33155 #endif
33156 }
33157 return resultobj;
33158 fail:
33159 return NULL;
33160 }
33161
33162
33163 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33164 PyObject *resultobj = 0;
33165 wxWindow *arg1 = (wxWindow *) 0 ;
33166 wxWindowVariant arg2 ;
33167 void *argp1 = 0 ;
33168 int res1 = 0 ;
33169 int val2 ;
33170 int ecode2 = 0 ;
33171 PyObject * obj0 = 0 ;
33172 PyObject * obj1 = 0 ;
33173 char * kwnames[] = {
33174 (char *) "self",(char *) "variant", NULL
33175 };
33176
33177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33179 if (!SWIG_IsOK(res1)) {
33180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33181 }
33182 arg1 = reinterpret_cast< wxWindow * >(argp1);
33183 ecode2 = SWIG_AsVal_int(obj1, &val2);
33184 if (!SWIG_IsOK(ecode2)) {
33185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33186 }
33187 arg2 = static_cast< wxWindowVariant >(val2);
33188 {
33189 PyThreadState* __tstate = wxPyBeginAllowThreads();
33190 (arg1)->SetWindowVariant(arg2);
33191 wxPyEndAllowThreads(__tstate);
33192 if (PyErr_Occurred()) SWIG_fail;
33193 }
33194 resultobj = SWIG_Py_Void();
33195 return resultobj;
33196 fail:
33197 return NULL;
33198 }
33199
33200
33201 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33202 PyObject *resultobj = 0;
33203 wxWindow *arg1 = (wxWindow *) 0 ;
33204 wxWindowVariant result;
33205 void *argp1 = 0 ;
33206 int res1 = 0 ;
33207 PyObject *swig_obj[1] ;
33208
33209 if (!args) SWIG_fail;
33210 swig_obj[0] = args;
33211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33212 if (!SWIG_IsOK(res1)) {
33213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33214 }
33215 arg1 = reinterpret_cast< wxWindow * >(argp1);
33216 {
33217 PyThreadState* __tstate = wxPyBeginAllowThreads();
33218 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33219 wxPyEndAllowThreads(__tstate);
33220 if (PyErr_Occurred()) SWIG_fail;
33221 }
33222 resultobj = SWIG_From_int(static_cast< int >(result));
33223 return resultobj;
33224 fail:
33225 return NULL;
33226 }
33227
33228
33229 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33230 PyObject *resultobj = 0;
33231 wxWindow *arg1 = (wxWindow *) 0 ;
33232 int arg2 ;
33233 void *argp1 = 0 ;
33234 int res1 = 0 ;
33235 int val2 ;
33236 int ecode2 = 0 ;
33237 PyObject * obj0 = 0 ;
33238 PyObject * obj1 = 0 ;
33239 char * kwnames[] = {
33240 (char *) "self",(char *) "winid", NULL
33241 };
33242
33243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33245 if (!SWIG_IsOK(res1)) {
33246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33247 }
33248 arg1 = reinterpret_cast< wxWindow * >(argp1);
33249 ecode2 = SWIG_AsVal_int(obj1, &val2);
33250 if (!SWIG_IsOK(ecode2)) {
33251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33252 }
33253 arg2 = static_cast< int >(val2);
33254 {
33255 PyThreadState* __tstate = wxPyBeginAllowThreads();
33256 (arg1)->SetId(arg2);
33257 wxPyEndAllowThreads(__tstate);
33258 if (PyErr_Occurred()) SWIG_fail;
33259 }
33260 resultobj = SWIG_Py_Void();
33261 return resultobj;
33262 fail:
33263 return NULL;
33264 }
33265
33266
33267 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33268 PyObject *resultobj = 0;
33269 wxWindow *arg1 = (wxWindow *) 0 ;
33270 int result;
33271 void *argp1 = 0 ;
33272 int res1 = 0 ;
33273 PyObject *swig_obj[1] ;
33274
33275 if (!args) SWIG_fail;
33276 swig_obj[0] = args;
33277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33278 if (!SWIG_IsOK(res1)) {
33279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33280 }
33281 arg1 = reinterpret_cast< wxWindow * >(argp1);
33282 {
33283 PyThreadState* __tstate = wxPyBeginAllowThreads();
33284 result = (int)((wxWindow const *)arg1)->GetId();
33285 wxPyEndAllowThreads(__tstate);
33286 if (PyErr_Occurred()) SWIG_fail;
33287 }
33288 resultobj = SWIG_From_int(static_cast< int >(result));
33289 return resultobj;
33290 fail:
33291 return NULL;
33292 }
33293
33294
33295 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33296 PyObject *resultobj = 0;
33297 int result;
33298
33299 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33300 {
33301 PyThreadState* __tstate = wxPyBeginAllowThreads();
33302 result = (int)wxWindow::NewControlId();
33303 wxPyEndAllowThreads(__tstate);
33304 if (PyErr_Occurred()) SWIG_fail;
33305 }
33306 resultobj = SWIG_From_int(static_cast< int >(result));
33307 return resultobj;
33308 fail:
33309 return NULL;
33310 }
33311
33312
33313 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33314 PyObject *resultobj = 0;
33315 int arg1 ;
33316 int result;
33317 int val1 ;
33318 int ecode1 = 0 ;
33319 PyObject * obj0 = 0 ;
33320 char * kwnames[] = {
33321 (char *) "winid", NULL
33322 };
33323
33324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33325 ecode1 = SWIG_AsVal_int(obj0, &val1);
33326 if (!SWIG_IsOK(ecode1)) {
33327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33328 }
33329 arg1 = static_cast< int >(val1);
33330 {
33331 PyThreadState* __tstate = wxPyBeginAllowThreads();
33332 result = (int)wxWindow::NextControlId(arg1);
33333 wxPyEndAllowThreads(__tstate);
33334 if (PyErr_Occurred()) SWIG_fail;
33335 }
33336 resultobj = SWIG_From_int(static_cast< int >(result));
33337 return resultobj;
33338 fail:
33339 return NULL;
33340 }
33341
33342
33343 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33344 PyObject *resultobj = 0;
33345 int arg1 ;
33346 int result;
33347 int val1 ;
33348 int ecode1 = 0 ;
33349 PyObject * obj0 = 0 ;
33350 char * kwnames[] = {
33351 (char *) "winid", NULL
33352 };
33353
33354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33355 ecode1 = SWIG_AsVal_int(obj0, &val1);
33356 if (!SWIG_IsOK(ecode1)) {
33357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33358 }
33359 arg1 = static_cast< int >(val1);
33360 {
33361 PyThreadState* __tstate = wxPyBeginAllowThreads();
33362 result = (int)wxWindow::PrevControlId(arg1);
33363 wxPyEndAllowThreads(__tstate);
33364 if (PyErr_Occurred()) SWIG_fail;
33365 }
33366 resultobj = SWIG_From_int(static_cast< int >(result));
33367 return resultobj;
33368 fail:
33369 return NULL;
33370 }
33371
33372
33373 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33374 PyObject *resultobj = 0;
33375 wxWindow *arg1 = (wxWindow *) 0 ;
33376 wxLayoutDirection result;
33377 void *argp1 = 0 ;
33378 int res1 = 0 ;
33379 PyObject *swig_obj[1] ;
33380
33381 if (!args) SWIG_fail;
33382 swig_obj[0] = args;
33383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33384 if (!SWIG_IsOK(res1)) {
33385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33386 }
33387 arg1 = reinterpret_cast< wxWindow * >(argp1);
33388 {
33389 PyThreadState* __tstate = wxPyBeginAllowThreads();
33390 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33391 wxPyEndAllowThreads(__tstate);
33392 if (PyErr_Occurred()) SWIG_fail;
33393 }
33394 resultobj = SWIG_From_int(static_cast< int >(result));
33395 return resultobj;
33396 fail:
33397 return NULL;
33398 }
33399
33400
33401 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33402 PyObject *resultobj = 0;
33403 wxWindow *arg1 = (wxWindow *) 0 ;
33404 wxLayoutDirection arg2 ;
33405 void *argp1 = 0 ;
33406 int res1 = 0 ;
33407 int val2 ;
33408 int ecode2 = 0 ;
33409 PyObject * obj0 = 0 ;
33410 PyObject * obj1 = 0 ;
33411 char * kwnames[] = {
33412 (char *) "self",(char *) "dir", NULL
33413 };
33414
33415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33417 if (!SWIG_IsOK(res1)) {
33418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33419 }
33420 arg1 = reinterpret_cast< wxWindow * >(argp1);
33421 ecode2 = SWIG_AsVal_int(obj1, &val2);
33422 if (!SWIG_IsOK(ecode2)) {
33423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33424 }
33425 arg2 = static_cast< wxLayoutDirection >(val2);
33426 {
33427 PyThreadState* __tstate = wxPyBeginAllowThreads();
33428 (arg1)->SetLayoutDirection(arg2);
33429 wxPyEndAllowThreads(__tstate);
33430 if (PyErr_Occurred()) SWIG_fail;
33431 }
33432 resultobj = SWIG_Py_Void();
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33440 PyObject *resultobj = 0;
33441 wxWindow *arg1 = (wxWindow *) 0 ;
33442 int arg2 ;
33443 int arg3 ;
33444 int arg4 ;
33445 int result;
33446 void *argp1 = 0 ;
33447 int res1 = 0 ;
33448 int val2 ;
33449 int ecode2 = 0 ;
33450 int val3 ;
33451 int ecode3 = 0 ;
33452 int val4 ;
33453 int ecode4 = 0 ;
33454 PyObject * obj0 = 0 ;
33455 PyObject * obj1 = 0 ;
33456 PyObject * obj2 = 0 ;
33457 PyObject * obj3 = 0 ;
33458 char * kwnames[] = {
33459 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33460 };
33461
33462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33464 if (!SWIG_IsOK(res1)) {
33465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33466 }
33467 arg1 = reinterpret_cast< wxWindow * >(argp1);
33468 ecode2 = SWIG_AsVal_int(obj1, &val2);
33469 if (!SWIG_IsOK(ecode2)) {
33470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33471 }
33472 arg2 = static_cast< int >(val2);
33473 ecode3 = SWIG_AsVal_int(obj2, &val3);
33474 if (!SWIG_IsOK(ecode3)) {
33475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33476 }
33477 arg3 = static_cast< int >(val3);
33478 ecode4 = SWIG_AsVal_int(obj3, &val4);
33479 if (!SWIG_IsOK(ecode4)) {
33480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33481 }
33482 arg4 = static_cast< int >(val4);
33483 {
33484 PyThreadState* __tstate = wxPyBeginAllowThreads();
33485 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33486 wxPyEndAllowThreads(__tstate);
33487 if (PyErr_Occurred()) SWIG_fail;
33488 }
33489 resultobj = SWIG_From_int(static_cast< int >(result));
33490 return resultobj;
33491 fail:
33492 return NULL;
33493 }
33494
33495
33496 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33497 PyObject *resultobj = 0;
33498 wxWindow *arg1 = (wxWindow *) 0 ;
33499 wxSize *arg2 = 0 ;
33500 void *argp1 = 0 ;
33501 int res1 = 0 ;
33502 wxSize temp2 ;
33503 PyObject * obj0 = 0 ;
33504 PyObject * obj1 = 0 ;
33505 char * kwnames[] = {
33506 (char *) "self",(char *) "size", NULL
33507 };
33508
33509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33511 if (!SWIG_IsOK(res1)) {
33512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33513 }
33514 arg1 = reinterpret_cast< wxWindow * >(argp1);
33515 {
33516 arg2 = &temp2;
33517 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33518 }
33519 {
33520 PyThreadState* __tstate = wxPyBeginAllowThreads();
33521 (arg1)->SetSize((wxSize const &)*arg2);
33522 wxPyEndAllowThreads(__tstate);
33523 if (PyErr_Occurred()) SWIG_fail;
33524 }
33525 resultobj = SWIG_Py_Void();
33526 return resultobj;
33527 fail:
33528 return NULL;
33529 }
33530
33531
33532 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33533 PyObject *resultobj = 0;
33534 wxWindow *arg1 = (wxWindow *) 0 ;
33535 int arg2 ;
33536 int arg3 ;
33537 int arg4 ;
33538 int arg5 ;
33539 int arg6 = (int) wxSIZE_AUTO ;
33540 void *argp1 = 0 ;
33541 int res1 = 0 ;
33542 int val2 ;
33543 int ecode2 = 0 ;
33544 int val3 ;
33545 int ecode3 = 0 ;
33546 int val4 ;
33547 int ecode4 = 0 ;
33548 int val5 ;
33549 int ecode5 = 0 ;
33550 int val6 ;
33551 int ecode6 = 0 ;
33552 PyObject * obj0 = 0 ;
33553 PyObject * obj1 = 0 ;
33554 PyObject * obj2 = 0 ;
33555 PyObject * obj3 = 0 ;
33556 PyObject * obj4 = 0 ;
33557 PyObject * obj5 = 0 ;
33558 char * kwnames[] = {
33559 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33560 };
33561
33562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33564 if (!SWIG_IsOK(res1)) {
33565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33566 }
33567 arg1 = reinterpret_cast< wxWindow * >(argp1);
33568 ecode2 = SWIG_AsVal_int(obj1, &val2);
33569 if (!SWIG_IsOK(ecode2)) {
33570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33571 }
33572 arg2 = static_cast< int >(val2);
33573 ecode3 = SWIG_AsVal_int(obj2, &val3);
33574 if (!SWIG_IsOK(ecode3)) {
33575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33576 }
33577 arg3 = static_cast< int >(val3);
33578 ecode4 = SWIG_AsVal_int(obj3, &val4);
33579 if (!SWIG_IsOK(ecode4)) {
33580 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33581 }
33582 arg4 = static_cast< int >(val4);
33583 ecode5 = SWIG_AsVal_int(obj4, &val5);
33584 if (!SWIG_IsOK(ecode5)) {
33585 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33586 }
33587 arg5 = static_cast< int >(val5);
33588 if (obj5) {
33589 ecode6 = SWIG_AsVal_int(obj5, &val6);
33590 if (!SWIG_IsOK(ecode6)) {
33591 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33592 }
33593 arg6 = static_cast< int >(val6);
33594 }
33595 {
33596 PyThreadState* __tstate = wxPyBeginAllowThreads();
33597 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33598 wxPyEndAllowThreads(__tstate);
33599 if (PyErr_Occurred()) SWIG_fail;
33600 }
33601 resultobj = SWIG_Py_Void();
33602 return resultobj;
33603 fail:
33604 return NULL;
33605 }
33606
33607
33608 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33609 PyObject *resultobj = 0;
33610 wxWindow *arg1 = (wxWindow *) 0 ;
33611 wxRect *arg2 = 0 ;
33612 int arg3 = (int) wxSIZE_AUTO ;
33613 void *argp1 = 0 ;
33614 int res1 = 0 ;
33615 wxRect temp2 ;
33616 int val3 ;
33617 int ecode3 = 0 ;
33618 PyObject * obj0 = 0 ;
33619 PyObject * obj1 = 0 ;
33620 PyObject * obj2 = 0 ;
33621 char * kwnames[] = {
33622 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33623 };
33624
33625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33627 if (!SWIG_IsOK(res1)) {
33628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33629 }
33630 arg1 = reinterpret_cast< wxWindow * >(argp1);
33631 {
33632 arg2 = &temp2;
33633 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33634 }
33635 if (obj2) {
33636 ecode3 = SWIG_AsVal_int(obj2, &val3);
33637 if (!SWIG_IsOK(ecode3)) {
33638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33639 }
33640 arg3 = static_cast< int >(val3);
33641 }
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 resultobj = SWIG_Py_Void();
33649 return resultobj;
33650 fail:
33651 return NULL;
33652 }
33653
33654
33655 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33656 PyObject *resultobj = 0;
33657 wxWindow *arg1 = (wxWindow *) 0 ;
33658 int arg2 ;
33659 int arg3 ;
33660 void *argp1 = 0 ;
33661 int res1 = 0 ;
33662 int val2 ;
33663 int ecode2 = 0 ;
33664 int val3 ;
33665 int ecode3 = 0 ;
33666 PyObject * obj0 = 0 ;
33667 PyObject * obj1 = 0 ;
33668 PyObject * obj2 = 0 ;
33669 char * kwnames[] = {
33670 (char *) "self",(char *) "width",(char *) "height", NULL
33671 };
33672
33673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33675 if (!SWIG_IsOK(res1)) {
33676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33677 }
33678 arg1 = reinterpret_cast< wxWindow * >(argp1);
33679 ecode2 = SWIG_AsVal_int(obj1, &val2);
33680 if (!SWIG_IsOK(ecode2)) {
33681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33682 }
33683 arg2 = static_cast< int >(val2);
33684 ecode3 = SWIG_AsVal_int(obj2, &val3);
33685 if (!SWIG_IsOK(ecode3)) {
33686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33687 }
33688 arg3 = static_cast< int >(val3);
33689 {
33690 PyThreadState* __tstate = wxPyBeginAllowThreads();
33691 (arg1)->SetSize(arg2,arg3);
33692 wxPyEndAllowThreads(__tstate);
33693 if (PyErr_Occurred()) SWIG_fail;
33694 }
33695 resultobj = SWIG_Py_Void();
33696 return resultobj;
33697 fail:
33698 return NULL;
33699 }
33700
33701
33702 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33703 PyObject *resultobj = 0;
33704 wxWindow *arg1 = (wxWindow *) 0 ;
33705 wxPoint *arg2 = 0 ;
33706 int arg3 = (int) wxSIZE_USE_EXISTING ;
33707 void *argp1 = 0 ;
33708 int res1 = 0 ;
33709 wxPoint temp2 ;
33710 int val3 ;
33711 int ecode3 = 0 ;
33712 PyObject * obj0 = 0 ;
33713 PyObject * obj1 = 0 ;
33714 PyObject * obj2 = 0 ;
33715 char * kwnames[] = {
33716 (char *) "self",(char *) "pt",(char *) "flags", NULL
33717 };
33718
33719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33721 if (!SWIG_IsOK(res1)) {
33722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33723 }
33724 arg1 = reinterpret_cast< wxWindow * >(argp1);
33725 {
33726 arg2 = &temp2;
33727 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33728 }
33729 if (obj2) {
33730 ecode3 = SWIG_AsVal_int(obj2, &val3);
33731 if (!SWIG_IsOK(ecode3)) {
33732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33733 }
33734 arg3 = static_cast< int >(val3);
33735 }
33736 {
33737 PyThreadState* __tstate = wxPyBeginAllowThreads();
33738 (arg1)->Move((wxPoint const &)*arg2,arg3);
33739 wxPyEndAllowThreads(__tstate);
33740 if (PyErr_Occurred()) SWIG_fail;
33741 }
33742 resultobj = SWIG_Py_Void();
33743 return resultobj;
33744 fail:
33745 return NULL;
33746 }
33747
33748
33749 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33750 PyObject *resultobj = 0;
33751 wxWindow *arg1 = (wxWindow *) 0 ;
33752 int arg2 ;
33753 int arg3 ;
33754 int arg4 = (int) wxSIZE_USE_EXISTING ;
33755 void *argp1 = 0 ;
33756 int res1 = 0 ;
33757 int val2 ;
33758 int ecode2 = 0 ;
33759 int val3 ;
33760 int ecode3 = 0 ;
33761 int val4 ;
33762 int ecode4 = 0 ;
33763 PyObject * obj0 = 0 ;
33764 PyObject * obj1 = 0 ;
33765 PyObject * obj2 = 0 ;
33766 PyObject * obj3 = 0 ;
33767 char * kwnames[] = {
33768 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33769 };
33770
33771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33773 if (!SWIG_IsOK(res1)) {
33774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33775 }
33776 arg1 = reinterpret_cast< wxWindow * >(argp1);
33777 ecode2 = SWIG_AsVal_int(obj1, &val2);
33778 if (!SWIG_IsOK(ecode2)) {
33779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33780 }
33781 arg2 = static_cast< int >(val2);
33782 ecode3 = SWIG_AsVal_int(obj2, &val3);
33783 if (!SWIG_IsOK(ecode3)) {
33784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33785 }
33786 arg3 = static_cast< int >(val3);
33787 if (obj3) {
33788 ecode4 = SWIG_AsVal_int(obj3, &val4);
33789 if (!SWIG_IsOK(ecode4)) {
33790 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33791 }
33792 arg4 = static_cast< int >(val4);
33793 }
33794 {
33795 PyThreadState* __tstate = wxPyBeginAllowThreads();
33796 (arg1)->Move(arg2,arg3,arg4);
33797 wxPyEndAllowThreads(__tstate);
33798 if (PyErr_Occurred()) SWIG_fail;
33799 }
33800 resultobj = SWIG_Py_Void();
33801 return resultobj;
33802 fail:
33803 return NULL;
33804 }
33805
33806
33807 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33808 PyObject *resultobj = 0;
33809 wxWindow *arg1 = (wxWindow *) 0 ;
33810 wxSize const &arg2_defvalue = wxDefaultSize ;
33811 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33812 void *argp1 = 0 ;
33813 int res1 = 0 ;
33814 wxSize temp2 ;
33815 PyObject * obj0 = 0 ;
33816 PyObject * obj1 = 0 ;
33817 char * kwnames[] = {
33818 (char *) "self",(char *) "size", NULL
33819 };
33820
33821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33823 if (!SWIG_IsOK(res1)) {
33824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33825 }
33826 arg1 = reinterpret_cast< wxWindow * >(argp1);
33827 if (obj1) {
33828 {
33829 arg2 = &temp2;
33830 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33831 }
33832 }
33833 {
33834 PyThreadState* __tstate = wxPyBeginAllowThreads();
33835 (arg1)->SetInitialSize((wxSize const &)*arg2);
33836 wxPyEndAllowThreads(__tstate);
33837 if (PyErr_Occurred()) SWIG_fail;
33838 }
33839 resultobj = SWIG_Py_Void();
33840 return resultobj;
33841 fail:
33842 return NULL;
33843 }
33844
33845
33846 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33847 PyObject *resultobj = 0;
33848 wxWindow *arg1 = (wxWindow *) 0 ;
33849 void *argp1 = 0 ;
33850 int res1 = 0 ;
33851 PyObject *swig_obj[1] ;
33852
33853 if (!args) SWIG_fail;
33854 swig_obj[0] = args;
33855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33856 if (!SWIG_IsOK(res1)) {
33857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33858 }
33859 arg1 = reinterpret_cast< wxWindow * >(argp1);
33860 {
33861 PyThreadState* __tstate = wxPyBeginAllowThreads();
33862 (arg1)->Raise();
33863 wxPyEndAllowThreads(__tstate);
33864 if (PyErr_Occurred()) SWIG_fail;
33865 }
33866 resultobj = SWIG_Py_Void();
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33874 PyObject *resultobj = 0;
33875 wxWindow *arg1 = (wxWindow *) 0 ;
33876 void *argp1 = 0 ;
33877 int res1 = 0 ;
33878 PyObject *swig_obj[1] ;
33879
33880 if (!args) SWIG_fail;
33881 swig_obj[0] = args;
33882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33883 if (!SWIG_IsOK(res1)) {
33884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33885 }
33886 arg1 = reinterpret_cast< wxWindow * >(argp1);
33887 {
33888 PyThreadState* __tstate = wxPyBeginAllowThreads();
33889 (arg1)->Lower();
33890 wxPyEndAllowThreads(__tstate);
33891 if (PyErr_Occurred()) SWIG_fail;
33892 }
33893 resultobj = SWIG_Py_Void();
33894 return resultobj;
33895 fail:
33896 return NULL;
33897 }
33898
33899
33900 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33901 PyObject *resultobj = 0;
33902 wxWindow *arg1 = (wxWindow *) 0 ;
33903 wxSize *arg2 = 0 ;
33904 void *argp1 = 0 ;
33905 int res1 = 0 ;
33906 wxSize temp2 ;
33907 PyObject * obj0 = 0 ;
33908 PyObject * obj1 = 0 ;
33909 char * kwnames[] = {
33910 (char *) "self",(char *) "size", NULL
33911 };
33912
33913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33915 if (!SWIG_IsOK(res1)) {
33916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33917 }
33918 arg1 = reinterpret_cast< wxWindow * >(argp1);
33919 {
33920 arg2 = &temp2;
33921 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33922 }
33923 {
33924 PyThreadState* __tstate = wxPyBeginAllowThreads();
33925 (arg1)->SetClientSize((wxSize const &)*arg2);
33926 wxPyEndAllowThreads(__tstate);
33927 if (PyErr_Occurred()) SWIG_fail;
33928 }
33929 resultobj = SWIG_Py_Void();
33930 return resultobj;
33931 fail:
33932 return NULL;
33933 }
33934
33935
33936 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33937 PyObject *resultobj = 0;
33938 wxWindow *arg1 = (wxWindow *) 0 ;
33939 int arg2 ;
33940 int arg3 ;
33941 void *argp1 = 0 ;
33942 int res1 = 0 ;
33943 int val2 ;
33944 int ecode2 = 0 ;
33945 int val3 ;
33946 int ecode3 = 0 ;
33947 PyObject * obj0 = 0 ;
33948 PyObject * obj1 = 0 ;
33949 PyObject * obj2 = 0 ;
33950 char * kwnames[] = {
33951 (char *) "self",(char *) "width",(char *) "height", NULL
33952 };
33953
33954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33956 if (!SWIG_IsOK(res1)) {
33957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33958 }
33959 arg1 = reinterpret_cast< wxWindow * >(argp1);
33960 ecode2 = SWIG_AsVal_int(obj1, &val2);
33961 if (!SWIG_IsOK(ecode2)) {
33962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33963 }
33964 arg2 = static_cast< int >(val2);
33965 ecode3 = SWIG_AsVal_int(obj2, &val3);
33966 if (!SWIG_IsOK(ecode3)) {
33967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33968 }
33969 arg3 = static_cast< int >(val3);
33970 {
33971 PyThreadState* __tstate = wxPyBeginAllowThreads();
33972 (arg1)->SetClientSize(arg2,arg3);
33973 wxPyEndAllowThreads(__tstate);
33974 if (PyErr_Occurred()) SWIG_fail;
33975 }
33976 resultobj = SWIG_Py_Void();
33977 return resultobj;
33978 fail:
33979 return NULL;
33980 }
33981
33982
33983 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33984 PyObject *resultobj = 0;
33985 wxWindow *arg1 = (wxWindow *) 0 ;
33986 wxRect *arg2 = 0 ;
33987 void *argp1 = 0 ;
33988 int res1 = 0 ;
33989 wxRect temp2 ;
33990 PyObject * obj0 = 0 ;
33991 PyObject * obj1 = 0 ;
33992 char * kwnames[] = {
33993 (char *) "self",(char *) "rect", NULL
33994 };
33995
33996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
33997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33998 if (!SWIG_IsOK(res1)) {
33999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34000 }
34001 arg1 = reinterpret_cast< wxWindow * >(argp1);
34002 {
34003 arg2 = &temp2;
34004 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34005 }
34006 {
34007 PyThreadState* __tstate = wxPyBeginAllowThreads();
34008 (arg1)->SetClientSize((wxRect const &)*arg2);
34009 wxPyEndAllowThreads(__tstate);
34010 if (PyErr_Occurred()) SWIG_fail;
34011 }
34012 resultobj = SWIG_Py_Void();
34013 return resultobj;
34014 fail:
34015 return NULL;
34016 }
34017
34018
34019 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34020 PyObject *resultobj = 0;
34021 wxWindow *arg1 = (wxWindow *) 0 ;
34022 wxPoint result;
34023 void *argp1 = 0 ;
34024 int res1 = 0 ;
34025 PyObject *swig_obj[1] ;
34026
34027 if (!args) SWIG_fail;
34028 swig_obj[0] = args;
34029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34030 if (!SWIG_IsOK(res1)) {
34031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34032 }
34033 arg1 = reinterpret_cast< wxWindow * >(argp1);
34034 {
34035 PyThreadState* __tstate = wxPyBeginAllowThreads();
34036 result = ((wxWindow const *)arg1)->GetPosition();
34037 wxPyEndAllowThreads(__tstate);
34038 if (PyErr_Occurred()) SWIG_fail;
34039 }
34040 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34041 return resultobj;
34042 fail:
34043 return NULL;
34044 }
34045
34046
34047 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34048 PyObject *resultobj = 0;
34049 wxWindow *arg1 = (wxWindow *) 0 ;
34050 int *arg2 = (int *) 0 ;
34051 int *arg3 = (int *) 0 ;
34052 void *argp1 = 0 ;
34053 int res1 = 0 ;
34054 int temp2 ;
34055 int res2 = SWIG_TMPOBJ ;
34056 int temp3 ;
34057 int res3 = SWIG_TMPOBJ ;
34058 PyObject *swig_obj[1] ;
34059
34060 arg2 = &temp2;
34061 arg3 = &temp3;
34062 if (!args) SWIG_fail;
34063 swig_obj[0] = args;
34064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34065 if (!SWIG_IsOK(res1)) {
34066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34067 }
34068 arg1 = reinterpret_cast< wxWindow * >(argp1);
34069 {
34070 PyThreadState* __tstate = wxPyBeginAllowThreads();
34071 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34072 wxPyEndAllowThreads(__tstate);
34073 if (PyErr_Occurred()) SWIG_fail;
34074 }
34075 resultobj = SWIG_Py_Void();
34076 if (SWIG_IsTmpObj(res2)) {
34077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34078 } else {
34079 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34081 }
34082 if (SWIG_IsTmpObj(res3)) {
34083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34084 } else {
34085 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34087 }
34088 return resultobj;
34089 fail:
34090 return NULL;
34091 }
34092
34093
34094 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34095 PyObject *resultobj = 0;
34096 wxWindow *arg1 = (wxWindow *) 0 ;
34097 wxPoint result;
34098 void *argp1 = 0 ;
34099 int res1 = 0 ;
34100 PyObject *swig_obj[1] ;
34101
34102 if (!args) SWIG_fail;
34103 swig_obj[0] = args;
34104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34105 if (!SWIG_IsOK(res1)) {
34106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34107 }
34108 arg1 = reinterpret_cast< wxWindow * >(argp1);
34109 {
34110 PyThreadState* __tstate = wxPyBeginAllowThreads();
34111 result = ((wxWindow const *)arg1)->GetScreenPosition();
34112 wxPyEndAllowThreads(__tstate);
34113 if (PyErr_Occurred()) SWIG_fail;
34114 }
34115 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34116 return resultobj;
34117 fail:
34118 return NULL;
34119 }
34120
34121
34122 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34123 PyObject *resultobj = 0;
34124 wxWindow *arg1 = (wxWindow *) 0 ;
34125 int *arg2 = (int *) 0 ;
34126 int *arg3 = (int *) 0 ;
34127 void *argp1 = 0 ;
34128 int res1 = 0 ;
34129 int temp2 ;
34130 int res2 = SWIG_TMPOBJ ;
34131 int temp3 ;
34132 int res3 = SWIG_TMPOBJ ;
34133 PyObject *swig_obj[1] ;
34134
34135 arg2 = &temp2;
34136 arg3 = &temp3;
34137 if (!args) SWIG_fail;
34138 swig_obj[0] = args;
34139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34140 if (!SWIG_IsOK(res1)) {
34141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34142 }
34143 arg1 = reinterpret_cast< wxWindow * >(argp1);
34144 {
34145 PyThreadState* __tstate = wxPyBeginAllowThreads();
34146 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34147 wxPyEndAllowThreads(__tstate);
34148 if (PyErr_Occurred()) SWIG_fail;
34149 }
34150 resultobj = SWIG_Py_Void();
34151 if (SWIG_IsTmpObj(res2)) {
34152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34153 } else {
34154 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34155 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34156 }
34157 if (SWIG_IsTmpObj(res3)) {
34158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34159 } else {
34160 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34162 }
34163 return resultobj;
34164 fail:
34165 return NULL;
34166 }
34167
34168
34169 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34170 PyObject *resultobj = 0;
34171 wxWindow *arg1 = (wxWindow *) 0 ;
34172 wxRect result;
34173 void *argp1 = 0 ;
34174 int res1 = 0 ;
34175 PyObject *swig_obj[1] ;
34176
34177 if (!args) SWIG_fail;
34178 swig_obj[0] = args;
34179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34180 if (!SWIG_IsOK(res1)) {
34181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34182 }
34183 arg1 = reinterpret_cast< wxWindow * >(argp1);
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 result = ((wxWindow const *)arg1)->GetScreenRect();
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34198 PyObject *resultobj = 0;
34199 wxWindow *arg1 = (wxWindow *) 0 ;
34200 wxSize result;
34201 void *argp1 = 0 ;
34202 int res1 = 0 ;
34203 PyObject *swig_obj[1] ;
34204
34205 if (!args) SWIG_fail;
34206 swig_obj[0] = args;
34207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34210 }
34211 arg1 = reinterpret_cast< wxWindow * >(argp1);
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 result = ((wxWindow const *)arg1)->GetSize();
34215 wxPyEndAllowThreads(__tstate);
34216 if (PyErr_Occurred()) SWIG_fail;
34217 }
34218 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34226 PyObject *resultobj = 0;
34227 wxWindow *arg1 = (wxWindow *) 0 ;
34228 int *arg2 = (int *) 0 ;
34229 int *arg3 = (int *) 0 ;
34230 void *argp1 = 0 ;
34231 int res1 = 0 ;
34232 int temp2 ;
34233 int res2 = SWIG_TMPOBJ ;
34234 int temp3 ;
34235 int res3 = SWIG_TMPOBJ ;
34236 PyObject *swig_obj[1] ;
34237
34238 arg2 = &temp2;
34239 arg3 = &temp3;
34240 if (!args) SWIG_fail;
34241 swig_obj[0] = args;
34242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34243 if (!SWIG_IsOK(res1)) {
34244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34245 }
34246 arg1 = reinterpret_cast< wxWindow * >(argp1);
34247 {
34248 PyThreadState* __tstate = wxPyBeginAllowThreads();
34249 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34250 wxPyEndAllowThreads(__tstate);
34251 if (PyErr_Occurred()) SWIG_fail;
34252 }
34253 resultobj = SWIG_Py_Void();
34254 if (SWIG_IsTmpObj(res2)) {
34255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34256 } else {
34257 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34259 }
34260 if (SWIG_IsTmpObj(res3)) {
34261 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34262 } else {
34263 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34265 }
34266 return resultobj;
34267 fail:
34268 return NULL;
34269 }
34270
34271
34272 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34273 PyObject *resultobj = 0;
34274 wxWindow *arg1 = (wxWindow *) 0 ;
34275 wxRect result;
34276 void *argp1 = 0 ;
34277 int res1 = 0 ;
34278 PyObject *swig_obj[1] ;
34279
34280 if (!args) SWIG_fail;
34281 swig_obj[0] = args;
34282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34283 if (!SWIG_IsOK(res1)) {
34284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34285 }
34286 arg1 = reinterpret_cast< wxWindow * >(argp1);
34287 {
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 result = ((wxWindow const *)arg1)->GetRect();
34290 wxPyEndAllowThreads(__tstate);
34291 if (PyErr_Occurred()) SWIG_fail;
34292 }
34293 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34294 return resultobj;
34295 fail:
34296 return NULL;
34297 }
34298
34299
34300 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34301 PyObject *resultobj = 0;
34302 wxWindow *arg1 = (wxWindow *) 0 ;
34303 wxSize result;
34304 void *argp1 = 0 ;
34305 int res1 = 0 ;
34306 PyObject *swig_obj[1] ;
34307
34308 if (!args) SWIG_fail;
34309 swig_obj[0] = args;
34310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34311 if (!SWIG_IsOK(res1)) {
34312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34313 }
34314 arg1 = reinterpret_cast< wxWindow * >(argp1);
34315 {
34316 PyThreadState* __tstate = wxPyBeginAllowThreads();
34317 result = ((wxWindow const *)arg1)->GetClientSize();
34318 wxPyEndAllowThreads(__tstate);
34319 if (PyErr_Occurred()) SWIG_fail;
34320 }
34321 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34322 return resultobj;
34323 fail:
34324 return NULL;
34325 }
34326
34327
34328 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34329 PyObject *resultobj = 0;
34330 wxWindow *arg1 = (wxWindow *) 0 ;
34331 int *arg2 = (int *) 0 ;
34332 int *arg3 = (int *) 0 ;
34333 void *argp1 = 0 ;
34334 int res1 = 0 ;
34335 int temp2 ;
34336 int res2 = SWIG_TMPOBJ ;
34337 int temp3 ;
34338 int res3 = SWIG_TMPOBJ ;
34339 PyObject *swig_obj[1] ;
34340
34341 arg2 = &temp2;
34342 arg3 = &temp3;
34343 if (!args) SWIG_fail;
34344 swig_obj[0] = args;
34345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34346 if (!SWIG_IsOK(res1)) {
34347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34348 }
34349 arg1 = reinterpret_cast< wxWindow * >(argp1);
34350 {
34351 PyThreadState* __tstate = wxPyBeginAllowThreads();
34352 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 resultobj = SWIG_Py_Void();
34357 if (SWIG_IsTmpObj(res2)) {
34358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34359 } else {
34360 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34362 }
34363 if (SWIG_IsTmpObj(res3)) {
34364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34365 } else {
34366 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34368 }
34369 return resultobj;
34370 fail:
34371 return NULL;
34372 }
34373
34374
34375 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34376 PyObject *resultobj = 0;
34377 wxWindow *arg1 = (wxWindow *) 0 ;
34378 wxPoint result;
34379 void *argp1 = 0 ;
34380 int res1 = 0 ;
34381 PyObject *swig_obj[1] ;
34382
34383 if (!args) SWIG_fail;
34384 swig_obj[0] = args;
34385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34386 if (!SWIG_IsOK(res1)) {
34387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34388 }
34389 arg1 = reinterpret_cast< wxWindow * >(argp1);
34390 {
34391 PyThreadState* __tstate = wxPyBeginAllowThreads();
34392 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34393 wxPyEndAllowThreads(__tstate);
34394 if (PyErr_Occurred()) SWIG_fail;
34395 }
34396 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34397 return resultobj;
34398 fail:
34399 return NULL;
34400 }
34401
34402
34403 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34404 PyObject *resultobj = 0;
34405 wxWindow *arg1 = (wxWindow *) 0 ;
34406 wxRect result;
34407 void *argp1 = 0 ;
34408 int res1 = 0 ;
34409 PyObject *swig_obj[1] ;
34410
34411 if (!args) SWIG_fail;
34412 swig_obj[0] = args;
34413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34414 if (!SWIG_IsOK(res1)) {
34415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34416 }
34417 arg1 = reinterpret_cast< wxWindow * >(argp1);
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 result = ((wxWindow const *)arg1)->GetClientRect();
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 PyObject *resultobj = 0;
34433 wxWindow *arg1 = (wxWindow *) 0 ;
34434 wxSize result;
34435 void *argp1 = 0 ;
34436 int res1 = 0 ;
34437 PyObject *swig_obj[1] ;
34438
34439 if (!args) SWIG_fail;
34440 swig_obj[0] = args;
34441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34442 if (!SWIG_IsOK(res1)) {
34443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34444 }
34445 arg1 = reinterpret_cast< wxWindow * >(argp1);
34446 {
34447 PyThreadState* __tstate = wxPyBeginAllowThreads();
34448 result = ((wxWindow const *)arg1)->GetBestSize();
34449 wxPyEndAllowThreads(__tstate);
34450 if (PyErr_Occurred()) SWIG_fail;
34451 }
34452 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34453 return resultobj;
34454 fail:
34455 return NULL;
34456 }
34457
34458
34459 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34460 PyObject *resultobj = 0;
34461 wxWindow *arg1 = (wxWindow *) 0 ;
34462 int *arg2 = (int *) 0 ;
34463 int *arg3 = (int *) 0 ;
34464 void *argp1 = 0 ;
34465 int res1 = 0 ;
34466 int temp2 ;
34467 int res2 = SWIG_TMPOBJ ;
34468 int temp3 ;
34469 int res3 = SWIG_TMPOBJ ;
34470 PyObject *swig_obj[1] ;
34471
34472 arg2 = &temp2;
34473 arg3 = &temp3;
34474 if (!args) SWIG_fail;
34475 swig_obj[0] = args;
34476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34477 if (!SWIG_IsOK(res1)) {
34478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34479 }
34480 arg1 = reinterpret_cast< wxWindow * >(argp1);
34481 {
34482 PyThreadState* __tstate = wxPyBeginAllowThreads();
34483 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34484 wxPyEndAllowThreads(__tstate);
34485 if (PyErr_Occurred()) SWIG_fail;
34486 }
34487 resultobj = SWIG_Py_Void();
34488 if (SWIG_IsTmpObj(res2)) {
34489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34490 } else {
34491 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34492 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34493 }
34494 if (SWIG_IsTmpObj(res3)) {
34495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34496 } else {
34497 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34499 }
34500 return resultobj;
34501 fail:
34502 return NULL;
34503 }
34504
34505
34506 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34507 PyObject *resultobj = 0;
34508 wxWindow *arg1 = (wxWindow *) 0 ;
34509 void *argp1 = 0 ;
34510 int res1 = 0 ;
34511 PyObject *swig_obj[1] ;
34512
34513 if (!args) SWIG_fail;
34514 swig_obj[0] = args;
34515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34516 if (!SWIG_IsOK(res1)) {
34517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34518 }
34519 arg1 = reinterpret_cast< wxWindow * >(argp1);
34520 {
34521 PyThreadState* __tstate = wxPyBeginAllowThreads();
34522 (arg1)->InvalidateBestSize();
34523 wxPyEndAllowThreads(__tstate);
34524 if (PyErr_Occurred()) SWIG_fail;
34525 }
34526 resultobj = SWIG_Py_Void();
34527 return resultobj;
34528 fail:
34529 return NULL;
34530 }
34531
34532
34533 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34534 PyObject *resultobj = 0;
34535 wxWindow *arg1 = (wxWindow *) 0 ;
34536 wxSize *arg2 = 0 ;
34537 void *argp1 = 0 ;
34538 int res1 = 0 ;
34539 wxSize temp2 ;
34540 PyObject * obj0 = 0 ;
34541 PyObject * obj1 = 0 ;
34542 char * kwnames[] = {
34543 (char *) "self",(char *) "size", NULL
34544 };
34545
34546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34548 if (!SWIG_IsOK(res1)) {
34549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34550 }
34551 arg1 = reinterpret_cast< wxWindow * >(argp1);
34552 {
34553 arg2 = &temp2;
34554 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34555 }
34556 {
34557 PyThreadState* __tstate = wxPyBeginAllowThreads();
34558 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34559 wxPyEndAllowThreads(__tstate);
34560 if (PyErr_Occurred()) SWIG_fail;
34561 }
34562 resultobj = SWIG_Py_Void();
34563 return resultobj;
34564 fail:
34565 return NULL;
34566 }
34567
34568
34569 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34570 PyObject *resultobj = 0;
34571 wxWindow *arg1 = (wxWindow *) 0 ;
34572 wxSize result;
34573 void *argp1 = 0 ;
34574 int res1 = 0 ;
34575 PyObject *swig_obj[1] ;
34576
34577 if (!args) SWIG_fail;
34578 swig_obj[0] = args;
34579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34580 if (!SWIG_IsOK(res1)) {
34581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34582 }
34583 arg1 = reinterpret_cast< wxWindow * >(argp1);
34584 {
34585 PyThreadState* __tstate = wxPyBeginAllowThreads();
34586 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34587 wxPyEndAllowThreads(__tstate);
34588 if (PyErr_Occurred()) SWIG_fail;
34589 }
34590 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34591 return resultobj;
34592 fail:
34593 return NULL;
34594 }
34595
34596
34597 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34598 PyObject *resultobj = 0;
34599 wxWindow *arg1 = (wxWindow *) 0 ;
34600 int arg2 = (int) wxBOTH ;
34601 void *argp1 = 0 ;
34602 int res1 = 0 ;
34603 int val2 ;
34604 int ecode2 = 0 ;
34605 PyObject * obj0 = 0 ;
34606 PyObject * obj1 = 0 ;
34607 char * kwnames[] = {
34608 (char *) "self",(char *) "direction", NULL
34609 };
34610
34611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34613 if (!SWIG_IsOK(res1)) {
34614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34615 }
34616 arg1 = reinterpret_cast< wxWindow * >(argp1);
34617 if (obj1) {
34618 ecode2 = SWIG_AsVal_int(obj1, &val2);
34619 if (!SWIG_IsOK(ecode2)) {
34620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34621 }
34622 arg2 = static_cast< int >(val2);
34623 }
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 (arg1)->Center(arg2);
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 resultobj = SWIG_Py_Void();
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34638 PyObject *resultobj = 0;
34639 wxWindow *arg1 = (wxWindow *) 0 ;
34640 int arg2 = (int) wxBOTH ;
34641 void *argp1 = 0 ;
34642 int res1 = 0 ;
34643 int val2 ;
34644 int ecode2 = 0 ;
34645 PyObject * obj0 = 0 ;
34646 PyObject * obj1 = 0 ;
34647 char * kwnames[] = {
34648 (char *) "self",(char *) "dir", NULL
34649 };
34650
34651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34653 if (!SWIG_IsOK(res1)) {
34654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34655 }
34656 arg1 = reinterpret_cast< wxWindow * >(argp1);
34657 if (obj1) {
34658 ecode2 = SWIG_AsVal_int(obj1, &val2);
34659 if (!SWIG_IsOK(ecode2)) {
34660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34661 }
34662 arg2 = static_cast< int >(val2);
34663 }
34664 {
34665 PyThreadState* __tstate = wxPyBeginAllowThreads();
34666 (arg1)->CenterOnParent(arg2);
34667 wxPyEndAllowThreads(__tstate);
34668 if (PyErr_Occurred()) SWIG_fail;
34669 }
34670 resultobj = SWIG_Py_Void();
34671 return resultobj;
34672 fail:
34673 return NULL;
34674 }
34675
34676
34677 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34678 PyObject *resultobj = 0;
34679 wxWindow *arg1 = (wxWindow *) 0 ;
34680 void *argp1 = 0 ;
34681 int res1 = 0 ;
34682 PyObject *swig_obj[1] ;
34683
34684 if (!args) SWIG_fail;
34685 swig_obj[0] = args;
34686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34687 if (!SWIG_IsOK(res1)) {
34688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34689 }
34690 arg1 = reinterpret_cast< wxWindow * >(argp1);
34691 {
34692 PyThreadState* __tstate = wxPyBeginAllowThreads();
34693 (arg1)->Fit();
34694 wxPyEndAllowThreads(__tstate);
34695 if (PyErr_Occurred()) SWIG_fail;
34696 }
34697 resultobj = SWIG_Py_Void();
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34705 PyObject *resultobj = 0;
34706 wxWindow *arg1 = (wxWindow *) 0 ;
34707 void *argp1 = 0 ;
34708 int res1 = 0 ;
34709 PyObject *swig_obj[1] ;
34710
34711 if (!args) SWIG_fail;
34712 swig_obj[0] = args;
34713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34714 if (!SWIG_IsOK(res1)) {
34715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34716 }
34717 arg1 = reinterpret_cast< wxWindow * >(argp1);
34718 {
34719 PyThreadState* __tstate = wxPyBeginAllowThreads();
34720 (arg1)->FitInside();
34721 wxPyEndAllowThreads(__tstate);
34722 if (PyErr_Occurred()) SWIG_fail;
34723 }
34724 resultobj = SWIG_Py_Void();
34725 return resultobj;
34726 fail:
34727 return NULL;
34728 }
34729
34730
34731 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34732 PyObject *resultobj = 0;
34733 wxWindow *arg1 = (wxWindow *) 0 ;
34734 int arg2 ;
34735 int arg3 ;
34736 int arg4 = (int) -1 ;
34737 int arg5 = (int) -1 ;
34738 int arg6 = (int) -1 ;
34739 int arg7 = (int) -1 ;
34740 void *argp1 = 0 ;
34741 int res1 = 0 ;
34742 int val2 ;
34743 int ecode2 = 0 ;
34744 int val3 ;
34745 int ecode3 = 0 ;
34746 int val4 ;
34747 int ecode4 = 0 ;
34748 int val5 ;
34749 int ecode5 = 0 ;
34750 int val6 ;
34751 int ecode6 = 0 ;
34752 int val7 ;
34753 int ecode7 = 0 ;
34754 PyObject * obj0 = 0 ;
34755 PyObject * obj1 = 0 ;
34756 PyObject * obj2 = 0 ;
34757 PyObject * obj3 = 0 ;
34758 PyObject * obj4 = 0 ;
34759 PyObject * obj5 = 0 ;
34760 PyObject * obj6 = 0 ;
34761 char * kwnames[] = {
34762 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34763 };
34764
34765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34767 if (!SWIG_IsOK(res1)) {
34768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34769 }
34770 arg1 = reinterpret_cast< wxWindow * >(argp1);
34771 ecode2 = SWIG_AsVal_int(obj1, &val2);
34772 if (!SWIG_IsOK(ecode2)) {
34773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34774 }
34775 arg2 = static_cast< int >(val2);
34776 ecode3 = SWIG_AsVal_int(obj2, &val3);
34777 if (!SWIG_IsOK(ecode3)) {
34778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34779 }
34780 arg3 = static_cast< int >(val3);
34781 if (obj3) {
34782 ecode4 = SWIG_AsVal_int(obj3, &val4);
34783 if (!SWIG_IsOK(ecode4)) {
34784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34785 }
34786 arg4 = static_cast< int >(val4);
34787 }
34788 if (obj4) {
34789 ecode5 = SWIG_AsVal_int(obj4, &val5);
34790 if (!SWIG_IsOK(ecode5)) {
34791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34792 }
34793 arg5 = static_cast< int >(val5);
34794 }
34795 if (obj5) {
34796 ecode6 = SWIG_AsVal_int(obj5, &val6);
34797 if (!SWIG_IsOK(ecode6)) {
34798 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34799 }
34800 arg6 = static_cast< int >(val6);
34801 }
34802 if (obj6) {
34803 ecode7 = SWIG_AsVal_int(obj6, &val7);
34804 if (!SWIG_IsOK(ecode7)) {
34805 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34806 }
34807 arg7 = static_cast< int >(val7);
34808 }
34809 {
34810 PyThreadState* __tstate = wxPyBeginAllowThreads();
34811 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34812 wxPyEndAllowThreads(__tstate);
34813 if (PyErr_Occurred()) SWIG_fail;
34814 }
34815 resultobj = SWIG_Py_Void();
34816 return resultobj;
34817 fail:
34818 return NULL;
34819 }
34820
34821
34822 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34823 PyObject *resultobj = 0;
34824 wxWindow *arg1 = (wxWindow *) 0 ;
34825 wxSize *arg2 = 0 ;
34826 wxSize const &arg3_defvalue = wxDefaultSize ;
34827 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34828 wxSize const &arg4_defvalue = wxDefaultSize ;
34829 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34830 void *argp1 = 0 ;
34831 int res1 = 0 ;
34832 wxSize temp2 ;
34833 wxSize temp3 ;
34834 wxSize temp4 ;
34835 PyObject * obj0 = 0 ;
34836 PyObject * obj1 = 0 ;
34837 PyObject * obj2 = 0 ;
34838 PyObject * obj3 = 0 ;
34839 char * kwnames[] = {
34840 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34841 };
34842
34843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34845 if (!SWIG_IsOK(res1)) {
34846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34847 }
34848 arg1 = reinterpret_cast< wxWindow * >(argp1);
34849 {
34850 arg2 = &temp2;
34851 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34852 }
34853 if (obj2) {
34854 {
34855 arg3 = &temp3;
34856 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34857 }
34858 }
34859 if (obj3) {
34860 {
34861 arg4 = &temp4;
34862 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34863 }
34864 }
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 resultobj = SWIG_Py_Void();
34872 return resultobj;
34873 fail:
34874 return NULL;
34875 }
34876
34877
34878 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34879 PyObject *resultobj = 0;
34880 wxWindow *arg1 = (wxWindow *) 0 ;
34881 int arg2 ;
34882 int arg3 ;
34883 int arg4 = (int) -1 ;
34884 int arg5 = (int) -1 ;
34885 void *argp1 = 0 ;
34886 int res1 = 0 ;
34887 int val2 ;
34888 int ecode2 = 0 ;
34889 int val3 ;
34890 int ecode3 = 0 ;
34891 int val4 ;
34892 int ecode4 = 0 ;
34893 int val5 ;
34894 int ecode5 = 0 ;
34895 PyObject * obj0 = 0 ;
34896 PyObject * obj1 = 0 ;
34897 PyObject * obj2 = 0 ;
34898 PyObject * obj3 = 0 ;
34899 PyObject * obj4 = 0 ;
34900 char * kwnames[] = {
34901 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34902 };
34903
34904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34906 if (!SWIG_IsOK(res1)) {
34907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34908 }
34909 arg1 = reinterpret_cast< wxWindow * >(argp1);
34910 ecode2 = SWIG_AsVal_int(obj1, &val2);
34911 if (!SWIG_IsOK(ecode2)) {
34912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34913 }
34914 arg2 = static_cast< int >(val2);
34915 ecode3 = SWIG_AsVal_int(obj2, &val3);
34916 if (!SWIG_IsOK(ecode3)) {
34917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34918 }
34919 arg3 = static_cast< int >(val3);
34920 if (obj3) {
34921 ecode4 = SWIG_AsVal_int(obj3, &val4);
34922 if (!SWIG_IsOK(ecode4)) {
34923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34924 }
34925 arg4 = static_cast< int >(val4);
34926 }
34927 if (obj4) {
34928 ecode5 = SWIG_AsVal_int(obj4, &val5);
34929 if (!SWIG_IsOK(ecode5)) {
34930 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34931 }
34932 arg5 = static_cast< int >(val5);
34933 }
34934 {
34935 PyThreadState* __tstate = wxPyBeginAllowThreads();
34936 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34937 wxPyEndAllowThreads(__tstate);
34938 if (PyErr_Occurred()) SWIG_fail;
34939 }
34940 resultobj = SWIG_Py_Void();
34941 return resultobj;
34942 fail:
34943 return NULL;
34944 }
34945
34946
34947 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34948 PyObject *resultobj = 0;
34949 wxWindow *arg1 = (wxWindow *) 0 ;
34950 wxSize *arg2 = 0 ;
34951 wxSize const &arg3_defvalue = wxDefaultSize ;
34952 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34953 void *argp1 = 0 ;
34954 int res1 = 0 ;
34955 wxSize temp2 ;
34956 wxSize temp3 ;
34957 PyObject * obj0 = 0 ;
34958 PyObject * obj1 = 0 ;
34959 PyObject * obj2 = 0 ;
34960 char * kwnames[] = {
34961 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34962 };
34963
34964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34966 if (!SWIG_IsOK(res1)) {
34967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34968 }
34969 arg1 = reinterpret_cast< wxWindow * >(argp1);
34970 {
34971 arg2 = &temp2;
34972 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34973 }
34974 if (obj2) {
34975 {
34976 arg3 = &temp3;
34977 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34978 }
34979 }
34980 {
34981 PyThreadState* __tstate = wxPyBeginAllowThreads();
34982 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
34983 wxPyEndAllowThreads(__tstate);
34984 if (PyErr_Occurred()) SWIG_fail;
34985 }
34986 resultobj = SWIG_Py_Void();
34987 return resultobj;
34988 fail:
34989 return NULL;
34990 }
34991
34992
34993 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34994 PyObject *resultobj = 0;
34995 wxWindow *arg1 = (wxWindow *) 0 ;
34996 wxSize result;
34997 void *argp1 = 0 ;
34998 int res1 = 0 ;
34999 PyObject *swig_obj[1] ;
35000
35001 if (!args) SWIG_fail;
35002 swig_obj[0] = args;
35003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35004 if (!SWIG_IsOK(res1)) {
35005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35006 }
35007 arg1 = reinterpret_cast< wxWindow * >(argp1);
35008 {
35009 PyThreadState* __tstate = wxPyBeginAllowThreads();
35010 result = ((wxWindow const *)arg1)->GetMaxSize();
35011 wxPyEndAllowThreads(__tstate);
35012 if (PyErr_Occurred()) SWIG_fail;
35013 }
35014 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35015 return resultobj;
35016 fail:
35017 return NULL;
35018 }
35019
35020
35021 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35022 PyObject *resultobj = 0;
35023 wxWindow *arg1 = (wxWindow *) 0 ;
35024 wxSize result;
35025 void *argp1 = 0 ;
35026 int res1 = 0 ;
35027 PyObject *swig_obj[1] ;
35028
35029 if (!args) SWIG_fail;
35030 swig_obj[0] = args;
35031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35032 if (!SWIG_IsOK(res1)) {
35033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35034 }
35035 arg1 = reinterpret_cast< wxWindow * >(argp1);
35036 {
35037 PyThreadState* __tstate = wxPyBeginAllowThreads();
35038 result = ((wxWindow const *)arg1)->GetMinSize();
35039 wxPyEndAllowThreads(__tstate);
35040 if (PyErr_Occurred()) SWIG_fail;
35041 }
35042 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35043 return resultobj;
35044 fail:
35045 return NULL;
35046 }
35047
35048
35049 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35050 PyObject *resultobj = 0;
35051 wxWindow *arg1 = (wxWindow *) 0 ;
35052 wxSize *arg2 = 0 ;
35053 void *argp1 = 0 ;
35054 int res1 = 0 ;
35055 wxSize temp2 ;
35056 PyObject * obj0 = 0 ;
35057 PyObject * obj1 = 0 ;
35058 char * kwnames[] = {
35059 (char *) "self",(char *) "minSize", NULL
35060 };
35061
35062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35064 if (!SWIG_IsOK(res1)) {
35065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35066 }
35067 arg1 = reinterpret_cast< wxWindow * >(argp1);
35068 {
35069 arg2 = &temp2;
35070 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35071 }
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 (arg1)->SetMinSize((wxSize const &)*arg2);
35075 wxPyEndAllowThreads(__tstate);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 }
35078 resultobj = SWIG_Py_Void();
35079 return resultobj;
35080 fail:
35081 return NULL;
35082 }
35083
35084
35085 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35086 PyObject *resultobj = 0;
35087 wxWindow *arg1 = (wxWindow *) 0 ;
35088 wxSize *arg2 = 0 ;
35089 void *argp1 = 0 ;
35090 int res1 = 0 ;
35091 wxSize temp2 ;
35092 PyObject * obj0 = 0 ;
35093 PyObject * obj1 = 0 ;
35094 char * kwnames[] = {
35095 (char *) "self",(char *) "maxSize", NULL
35096 };
35097
35098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35100 if (!SWIG_IsOK(res1)) {
35101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35102 }
35103 arg1 = reinterpret_cast< wxWindow * >(argp1);
35104 {
35105 arg2 = &temp2;
35106 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35107 }
35108 {
35109 PyThreadState* __tstate = wxPyBeginAllowThreads();
35110 (arg1)->SetMaxSize((wxSize const &)*arg2);
35111 wxPyEndAllowThreads(__tstate);
35112 if (PyErr_Occurred()) SWIG_fail;
35113 }
35114 resultobj = SWIG_Py_Void();
35115 return resultobj;
35116 fail:
35117 return NULL;
35118 }
35119
35120
35121 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35122 PyObject *resultobj = 0;
35123 wxWindow *arg1 = (wxWindow *) 0 ;
35124 int result;
35125 void *argp1 = 0 ;
35126 int res1 = 0 ;
35127 PyObject *swig_obj[1] ;
35128
35129 if (!args) SWIG_fail;
35130 swig_obj[0] = args;
35131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35132 if (!SWIG_IsOK(res1)) {
35133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35134 }
35135 arg1 = reinterpret_cast< wxWindow * >(argp1);
35136 {
35137 PyThreadState* __tstate = wxPyBeginAllowThreads();
35138 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35139 wxPyEndAllowThreads(__tstate);
35140 if (PyErr_Occurred()) SWIG_fail;
35141 }
35142 resultobj = SWIG_From_int(static_cast< int >(result));
35143 return resultobj;
35144 fail:
35145 return NULL;
35146 }
35147
35148
35149 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35150 PyObject *resultobj = 0;
35151 wxWindow *arg1 = (wxWindow *) 0 ;
35152 int result;
35153 void *argp1 = 0 ;
35154 int res1 = 0 ;
35155 PyObject *swig_obj[1] ;
35156
35157 if (!args) SWIG_fail;
35158 swig_obj[0] = args;
35159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35160 if (!SWIG_IsOK(res1)) {
35161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35162 }
35163 arg1 = reinterpret_cast< wxWindow * >(argp1);
35164 {
35165 PyThreadState* __tstate = wxPyBeginAllowThreads();
35166 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35167 wxPyEndAllowThreads(__tstate);
35168 if (PyErr_Occurred()) SWIG_fail;
35169 }
35170 resultobj = SWIG_From_int(static_cast< int >(result));
35171 return resultobj;
35172 fail:
35173 return NULL;
35174 }
35175
35176
35177 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35178 PyObject *resultobj = 0;
35179 wxWindow *arg1 = (wxWindow *) 0 ;
35180 int result;
35181 void *argp1 = 0 ;
35182 int res1 = 0 ;
35183 PyObject *swig_obj[1] ;
35184
35185 if (!args) SWIG_fail;
35186 swig_obj[0] = args;
35187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35188 if (!SWIG_IsOK(res1)) {
35189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35190 }
35191 arg1 = reinterpret_cast< wxWindow * >(argp1);
35192 {
35193 PyThreadState* __tstate = wxPyBeginAllowThreads();
35194 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 resultobj = SWIG_From_int(static_cast< int >(result));
35199 return resultobj;
35200 fail:
35201 return NULL;
35202 }
35203
35204
35205 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35206 PyObject *resultobj = 0;
35207 wxWindow *arg1 = (wxWindow *) 0 ;
35208 int result;
35209 void *argp1 = 0 ;
35210 int res1 = 0 ;
35211 PyObject *swig_obj[1] ;
35212
35213 if (!args) SWIG_fail;
35214 swig_obj[0] = args;
35215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35216 if (!SWIG_IsOK(res1)) {
35217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35218 }
35219 arg1 = reinterpret_cast< wxWindow * >(argp1);
35220 {
35221 PyThreadState* __tstate = wxPyBeginAllowThreads();
35222 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35223 wxPyEndAllowThreads(__tstate);
35224 if (PyErr_Occurred()) SWIG_fail;
35225 }
35226 resultobj = SWIG_From_int(static_cast< int >(result));
35227 return resultobj;
35228 fail:
35229 return NULL;
35230 }
35231
35232
35233 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35234 PyObject *resultobj = 0;
35235 wxWindow *arg1 = (wxWindow *) 0 ;
35236 wxSize *arg2 = 0 ;
35237 void *argp1 = 0 ;
35238 int res1 = 0 ;
35239 wxSize temp2 ;
35240 PyObject * obj0 = 0 ;
35241 PyObject * obj1 = 0 ;
35242 char * kwnames[] = {
35243 (char *) "self",(char *) "size", NULL
35244 };
35245
35246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35248 if (!SWIG_IsOK(res1)) {
35249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35250 }
35251 arg1 = reinterpret_cast< wxWindow * >(argp1);
35252 {
35253 arg2 = &temp2;
35254 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35255 }
35256 {
35257 PyThreadState* __tstate = wxPyBeginAllowThreads();
35258 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35259 wxPyEndAllowThreads(__tstate);
35260 if (PyErr_Occurred()) SWIG_fail;
35261 }
35262 resultobj = SWIG_Py_Void();
35263 return resultobj;
35264 fail:
35265 return NULL;
35266 }
35267
35268
35269 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35270 PyObject *resultobj = 0;
35271 wxWindow *arg1 = (wxWindow *) 0 ;
35272 int arg2 ;
35273 int arg3 ;
35274 void *argp1 = 0 ;
35275 int res1 = 0 ;
35276 int val2 ;
35277 int ecode2 = 0 ;
35278 int val3 ;
35279 int ecode3 = 0 ;
35280 PyObject * obj0 = 0 ;
35281 PyObject * obj1 = 0 ;
35282 PyObject * obj2 = 0 ;
35283 char * kwnames[] = {
35284 (char *) "self",(char *) "w",(char *) "h", NULL
35285 };
35286
35287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35289 if (!SWIG_IsOK(res1)) {
35290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35291 }
35292 arg1 = reinterpret_cast< wxWindow * >(argp1);
35293 ecode2 = SWIG_AsVal_int(obj1, &val2);
35294 if (!SWIG_IsOK(ecode2)) {
35295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35296 }
35297 arg2 = static_cast< int >(val2);
35298 ecode3 = SWIG_AsVal_int(obj2, &val3);
35299 if (!SWIG_IsOK(ecode3)) {
35300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35301 }
35302 arg3 = static_cast< int >(val3);
35303 {
35304 PyThreadState* __tstate = wxPyBeginAllowThreads();
35305 (arg1)->SetVirtualSize(arg2,arg3);
35306 wxPyEndAllowThreads(__tstate);
35307 if (PyErr_Occurred()) SWIG_fail;
35308 }
35309 resultobj = SWIG_Py_Void();
35310 return resultobj;
35311 fail:
35312 return NULL;
35313 }
35314
35315
35316 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35317 PyObject *resultobj = 0;
35318 wxWindow *arg1 = (wxWindow *) 0 ;
35319 wxSize result;
35320 void *argp1 = 0 ;
35321 int res1 = 0 ;
35322 PyObject *swig_obj[1] ;
35323
35324 if (!args) SWIG_fail;
35325 swig_obj[0] = args;
35326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35327 if (!SWIG_IsOK(res1)) {
35328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35329 }
35330 arg1 = reinterpret_cast< wxWindow * >(argp1);
35331 {
35332 PyThreadState* __tstate = wxPyBeginAllowThreads();
35333 result = ((wxWindow const *)arg1)->GetVirtualSize();
35334 wxPyEndAllowThreads(__tstate);
35335 if (PyErr_Occurred()) SWIG_fail;
35336 }
35337 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35338 return resultobj;
35339 fail:
35340 return NULL;
35341 }
35342
35343
35344 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35345 PyObject *resultobj = 0;
35346 wxWindow *arg1 = (wxWindow *) 0 ;
35347 int *arg2 = (int *) 0 ;
35348 int *arg3 = (int *) 0 ;
35349 void *argp1 = 0 ;
35350 int res1 = 0 ;
35351 int temp2 ;
35352 int res2 = SWIG_TMPOBJ ;
35353 int temp3 ;
35354 int res3 = SWIG_TMPOBJ ;
35355 PyObject *swig_obj[1] ;
35356
35357 arg2 = &temp2;
35358 arg3 = &temp3;
35359 if (!args) SWIG_fail;
35360 swig_obj[0] = args;
35361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35362 if (!SWIG_IsOK(res1)) {
35363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35364 }
35365 arg1 = reinterpret_cast< wxWindow * >(argp1);
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35369 wxPyEndAllowThreads(__tstate);
35370 if (PyErr_Occurred()) SWIG_fail;
35371 }
35372 resultobj = SWIG_Py_Void();
35373 if (SWIG_IsTmpObj(res2)) {
35374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35375 } else {
35376 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35378 }
35379 if (SWIG_IsTmpObj(res3)) {
35380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35381 } else {
35382 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35384 }
35385 return resultobj;
35386 fail:
35387 return NULL;
35388 }
35389
35390
35391 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35392 PyObject *resultobj = 0;
35393 wxWindow *arg1 = (wxWindow *) 0 ;
35394 wxSize result;
35395 void *argp1 = 0 ;
35396 int res1 = 0 ;
35397 PyObject *swig_obj[1] ;
35398
35399 if (!args) SWIG_fail;
35400 swig_obj[0] = args;
35401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35402 if (!SWIG_IsOK(res1)) {
35403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35404 }
35405 arg1 = reinterpret_cast< wxWindow * >(argp1);
35406 {
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35409 wxPyEndAllowThreads(__tstate);
35410 if (PyErr_Occurred()) SWIG_fail;
35411 }
35412 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35413 return resultobj;
35414 fail:
35415 return NULL;
35416 }
35417
35418
35419 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35420 PyObject *resultobj = 0;
35421 wxWindow *arg1 = (wxWindow *) 0 ;
35422 bool arg2 = (bool) true ;
35423 bool result;
35424 void *argp1 = 0 ;
35425 int res1 = 0 ;
35426 bool val2 ;
35427 int ecode2 = 0 ;
35428 PyObject * obj0 = 0 ;
35429 PyObject * obj1 = 0 ;
35430 char * kwnames[] = {
35431 (char *) "self",(char *) "show", NULL
35432 };
35433
35434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35436 if (!SWIG_IsOK(res1)) {
35437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35438 }
35439 arg1 = reinterpret_cast< wxWindow * >(argp1);
35440 if (obj1) {
35441 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35442 if (!SWIG_IsOK(ecode2)) {
35443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35444 }
35445 arg2 = static_cast< bool >(val2);
35446 }
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 result = (bool)(arg1)->Show(arg2);
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 {
35454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35455 }
35456 return resultobj;
35457 fail:
35458 return NULL;
35459 }
35460
35461
35462 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35463 PyObject *resultobj = 0;
35464 wxWindow *arg1 = (wxWindow *) 0 ;
35465 bool result;
35466 void *argp1 = 0 ;
35467 int res1 = 0 ;
35468 PyObject *swig_obj[1] ;
35469
35470 if (!args) SWIG_fail;
35471 swig_obj[0] = args;
35472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35473 if (!SWIG_IsOK(res1)) {
35474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35475 }
35476 arg1 = reinterpret_cast< wxWindow * >(argp1);
35477 {
35478 PyThreadState* __tstate = wxPyBeginAllowThreads();
35479 result = (bool)(arg1)->Hide();
35480 wxPyEndAllowThreads(__tstate);
35481 if (PyErr_Occurred()) SWIG_fail;
35482 }
35483 {
35484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35485 }
35486 return resultobj;
35487 fail:
35488 return NULL;
35489 }
35490
35491
35492 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35493 PyObject *resultobj = 0;
35494 wxWindow *arg1 = (wxWindow *) 0 ;
35495 bool arg2 = (bool) true ;
35496 bool result;
35497 void *argp1 = 0 ;
35498 int res1 = 0 ;
35499 bool val2 ;
35500 int ecode2 = 0 ;
35501 PyObject * obj0 = 0 ;
35502 PyObject * obj1 = 0 ;
35503 char * kwnames[] = {
35504 (char *) "self",(char *) "enable", NULL
35505 };
35506
35507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35509 if (!SWIG_IsOK(res1)) {
35510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35511 }
35512 arg1 = reinterpret_cast< wxWindow * >(argp1);
35513 if (obj1) {
35514 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35515 if (!SWIG_IsOK(ecode2)) {
35516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35517 }
35518 arg2 = static_cast< bool >(val2);
35519 }
35520 {
35521 PyThreadState* __tstate = wxPyBeginAllowThreads();
35522 result = (bool)(arg1)->Enable(arg2);
35523 wxPyEndAllowThreads(__tstate);
35524 if (PyErr_Occurred()) SWIG_fail;
35525 }
35526 {
35527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35528 }
35529 return resultobj;
35530 fail:
35531 return NULL;
35532 }
35533
35534
35535 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35536 PyObject *resultobj = 0;
35537 wxWindow *arg1 = (wxWindow *) 0 ;
35538 bool result;
35539 void *argp1 = 0 ;
35540 int res1 = 0 ;
35541 PyObject *swig_obj[1] ;
35542
35543 if (!args) SWIG_fail;
35544 swig_obj[0] = args;
35545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35546 if (!SWIG_IsOK(res1)) {
35547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35548 }
35549 arg1 = reinterpret_cast< wxWindow * >(argp1);
35550 {
35551 PyThreadState* __tstate = wxPyBeginAllowThreads();
35552 result = (bool)(arg1)->Disable();
35553 wxPyEndAllowThreads(__tstate);
35554 if (PyErr_Occurred()) SWIG_fail;
35555 }
35556 {
35557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35558 }
35559 return resultobj;
35560 fail:
35561 return NULL;
35562 }
35563
35564
35565 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35566 PyObject *resultobj = 0;
35567 wxWindow *arg1 = (wxWindow *) 0 ;
35568 bool result;
35569 void *argp1 = 0 ;
35570 int res1 = 0 ;
35571 PyObject *swig_obj[1] ;
35572
35573 if (!args) SWIG_fail;
35574 swig_obj[0] = args;
35575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35576 if (!SWIG_IsOK(res1)) {
35577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35578 }
35579 arg1 = reinterpret_cast< wxWindow * >(argp1);
35580 {
35581 PyThreadState* __tstate = wxPyBeginAllowThreads();
35582 result = (bool)((wxWindow const *)arg1)->IsShown();
35583 wxPyEndAllowThreads(__tstate);
35584 if (PyErr_Occurred()) SWIG_fail;
35585 }
35586 {
35587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35588 }
35589 return resultobj;
35590 fail:
35591 return NULL;
35592 }
35593
35594
35595 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35596 PyObject *resultobj = 0;
35597 wxWindow *arg1 = (wxWindow *) 0 ;
35598 bool result;
35599 void *argp1 = 0 ;
35600 int res1 = 0 ;
35601 PyObject *swig_obj[1] ;
35602
35603 if (!args) SWIG_fail;
35604 swig_obj[0] = args;
35605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35606 if (!SWIG_IsOK(res1)) {
35607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35608 }
35609 arg1 = reinterpret_cast< wxWindow * >(argp1);
35610 {
35611 PyThreadState* __tstate = wxPyBeginAllowThreads();
35612 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35613 wxPyEndAllowThreads(__tstate);
35614 if (PyErr_Occurred()) SWIG_fail;
35615 }
35616 {
35617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35618 }
35619 return resultobj;
35620 fail:
35621 return NULL;
35622 }
35623
35624
35625 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35626 PyObject *resultobj = 0;
35627 wxWindow *arg1 = (wxWindow *) 0 ;
35628 bool result;
35629 void *argp1 = 0 ;
35630 int res1 = 0 ;
35631 PyObject *swig_obj[1] ;
35632
35633 if (!args) SWIG_fail;
35634 swig_obj[0] = args;
35635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35636 if (!SWIG_IsOK(res1)) {
35637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35638 }
35639 arg1 = reinterpret_cast< wxWindow * >(argp1);
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35643 wxPyEndAllowThreads(__tstate);
35644 if (PyErr_Occurred()) SWIG_fail;
35645 }
35646 {
35647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35648 }
35649 return resultobj;
35650 fail:
35651 return NULL;
35652 }
35653
35654
35655 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35656 PyObject *resultobj = 0;
35657 wxWindow *arg1 = (wxWindow *) 0 ;
35658 long arg2 ;
35659 void *argp1 = 0 ;
35660 int res1 = 0 ;
35661 long val2 ;
35662 int ecode2 = 0 ;
35663 PyObject * obj0 = 0 ;
35664 PyObject * obj1 = 0 ;
35665 char * kwnames[] = {
35666 (char *) "self",(char *) "style", NULL
35667 };
35668
35669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35673 }
35674 arg1 = reinterpret_cast< wxWindow * >(argp1);
35675 ecode2 = SWIG_AsVal_long(obj1, &val2);
35676 if (!SWIG_IsOK(ecode2)) {
35677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35678 }
35679 arg2 = static_cast< long >(val2);
35680 {
35681 PyThreadState* __tstate = wxPyBeginAllowThreads();
35682 (arg1)->SetWindowStyleFlag(arg2);
35683 wxPyEndAllowThreads(__tstate);
35684 if (PyErr_Occurred()) SWIG_fail;
35685 }
35686 resultobj = SWIG_Py_Void();
35687 return resultobj;
35688 fail:
35689 return NULL;
35690 }
35691
35692
35693 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35694 PyObject *resultobj = 0;
35695 wxWindow *arg1 = (wxWindow *) 0 ;
35696 long result;
35697 void *argp1 = 0 ;
35698 int res1 = 0 ;
35699 PyObject *swig_obj[1] ;
35700
35701 if (!args) SWIG_fail;
35702 swig_obj[0] = args;
35703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35704 if (!SWIG_IsOK(res1)) {
35705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35706 }
35707 arg1 = reinterpret_cast< wxWindow * >(argp1);
35708 {
35709 PyThreadState* __tstate = wxPyBeginAllowThreads();
35710 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35711 wxPyEndAllowThreads(__tstate);
35712 if (PyErr_Occurred()) SWIG_fail;
35713 }
35714 resultobj = SWIG_From_long(static_cast< long >(result));
35715 return resultobj;
35716 fail:
35717 return NULL;
35718 }
35719
35720
35721 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35722 PyObject *resultobj = 0;
35723 wxWindow *arg1 = (wxWindow *) 0 ;
35724 int arg2 ;
35725 bool result;
35726 void *argp1 = 0 ;
35727 int res1 = 0 ;
35728 int val2 ;
35729 int ecode2 = 0 ;
35730 PyObject * obj0 = 0 ;
35731 PyObject * obj1 = 0 ;
35732 char * kwnames[] = {
35733 (char *) "self",(char *) "flag", NULL
35734 };
35735
35736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35738 if (!SWIG_IsOK(res1)) {
35739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35740 }
35741 arg1 = reinterpret_cast< wxWindow * >(argp1);
35742 ecode2 = SWIG_AsVal_int(obj1, &val2);
35743 if (!SWIG_IsOK(ecode2)) {
35744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35745 }
35746 arg2 = static_cast< int >(val2);
35747 {
35748 PyThreadState* __tstate = wxPyBeginAllowThreads();
35749 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35750 wxPyEndAllowThreads(__tstate);
35751 if (PyErr_Occurred()) SWIG_fail;
35752 }
35753 {
35754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35755 }
35756 return resultobj;
35757 fail:
35758 return NULL;
35759 }
35760
35761
35762 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35763 PyObject *resultobj = 0;
35764 wxWindow *arg1 = (wxWindow *) 0 ;
35765 bool result;
35766 void *argp1 = 0 ;
35767 int res1 = 0 ;
35768 PyObject *swig_obj[1] ;
35769
35770 if (!args) SWIG_fail;
35771 swig_obj[0] = args;
35772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35773 if (!SWIG_IsOK(res1)) {
35774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35775 }
35776 arg1 = reinterpret_cast< wxWindow * >(argp1);
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 result = (bool)((wxWindow const *)arg1)->IsRetained();
35780 wxPyEndAllowThreads(__tstate);
35781 if (PyErr_Occurred()) SWIG_fail;
35782 }
35783 {
35784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35785 }
35786 return resultobj;
35787 fail:
35788 return NULL;
35789 }
35790
35791
35792 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35793 PyObject *resultobj = 0;
35794 wxWindow *arg1 = (wxWindow *) 0 ;
35795 long arg2 ;
35796 void *argp1 = 0 ;
35797 int res1 = 0 ;
35798 long val2 ;
35799 int ecode2 = 0 ;
35800 PyObject * obj0 = 0 ;
35801 PyObject * obj1 = 0 ;
35802 char * kwnames[] = {
35803 (char *) "self",(char *) "exStyle", NULL
35804 };
35805
35806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35808 if (!SWIG_IsOK(res1)) {
35809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35810 }
35811 arg1 = reinterpret_cast< wxWindow * >(argp1);
35812 ecode2 = SWIG_AsVal_long(obj1, &val2);
35813 if (!SWIG_IsOK(ecode2)) {
35814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35815 }
35816 arg2 = static_cast< long >(val2);
35817 {
35818 PyThreadState* __tstate = wxPyBeginAllowThreads();
35819 (arg1)->SetExtraStyle(arg2);
35820 wxPyEndAllowThreads(__tstate);
35821 if (PyErr_Occurred()) SWIG_fail;
35822 }
35823 resultobj = SWIG_Py_Void();
35824 return resultobj;
35825 fail:
35826 return NULL;
35827 }
35828
35829
35830 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35831 PyObject *resultobj = 0;
35832 wxWindow *arg1 = (wxWindow *) 0 ;
35833 long result;
35834 void *argp1 = 0 ;
35835 int res1 = 0 ;
35836 PyObject *swig_obj[1] ;
35837
35838 if (!args) SWIG_fail;
35839 swig_obj[0] = args;
35840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35843 }
35844 arg1 = reinterpret_cast< wxWindow * >(argp1);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 resultobj = SWIG_From_long(static_cast< long >(result));
35852 return resultobj;
35853 fail:
35854 return NULL;
35855 }
35856
35857
35858 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35859 PyObject *resultobj = 0;
35860 wxWindow *arg1 = (wxWindow *) 0 ;
35861 bool arg2 = (bool) true ;
35862 void *argp1 = 0 ;
35863 int res1 = 0 ;
35864 bool val2 ;
35865 int ecode2 = 0 ;
35866 PyObject * obj0 = 0 ;
35867 PyObject * obj1 = 0 ;
35868 char * kwnames[] = {
35869 (char *) "self",(char *) "modal", NULL
35870 };
35871
35872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35874 if (!SWIG_IsOK(res1)) {
35875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35876 }
35877 arg1 = reinterpret_cast< wxWindow * >(argp1);
35878 if (obj1) {
35879 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35880 if (!SWIG_IsOK(ecode2)) {
35881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35882 }
35883 arg2 = static_cast< bool >(val2);
35884 }
35885 {
35886 PyThreadState* __tstate = wxPyBeginAllowThreads();
35887 (arg1)->MakeModal(arg2);
35888 wxPyEndAllowThreads(__tstate);
35889 if (PyErr_Occurred()) SWIG_fail;
35890 }
35891 resultobj = SWIG_Py_Void();
35892 return resultobj;
35893 fail:
35894 return NULL;
35895 }
35896
35897
35898 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35899 PyObject *resultobj = 0;
35900 wxWindow *arg1 = (wxWindow *) 0 ;
35901 bool arg2 ;
35902 void *argp1 = 0 ;
35903 int res1 = 0 ;
35904 bool val2 ;
35905 int ecode2 = 0 ;
35906 PyObject * obj0 = 0 ;
35907 PyObject * obj1 = 0 ;
35908 char * kwnames[] = {
35909 (char *) "self",(char *) "enableTheme", NULL
35910 };
35911
35912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35914 if (!SWIG_IsOK(res1)) {
35915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35916 }
35917 arg1 = reinterpret_cast< wxWindow * >(argp1);
35918 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35919 if (!SWIG_IsOK(ecode2)) {
35920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35921 }
35922 arg2 = static_cast< bool >(val2);
35923 {
35924 PyThreadState* __tstate = wxPyBeginAllowThreads();
35925 (arg1)->SetThemeEnabled(arg2);
35926 wxPyEndAllowThreads(__tstate);
35927 if (PyErr_Occurred()) SWIG_fail;
35928 }
35929 resultobj = SWIG_Py_Void();
35930 return resultobj;
35931 fail:
35932 return NULL;
35933 }
35934
35935
35936 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35937 PyObject *resultobj = 0;
35938 wxWindow *arg1 = (wxWindow *) 0 ;
35939 bool result;
35940 void *argp1 = 0 ;
35941 int res1 = 0 ;
35942 PyObject *swig_obj[1] ;
35943
35944 if (!args) SWIG_fail;
35945 swig_obj[0] = args;
35946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35947 if (!SWIG_IsOK(res1)) {
35948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35949 }
35950 arg1 = reinterpret_cast< wxWindow * >(argp1);
35951 {
35952 PyThreadState* __tstate = wxPyBeginAllowThreads();
35953 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
35954 wxPyEndAllowThreads(__tstate);
35955 if (PyErr_Occurred()) SWIG_fail;
35956 }
35957 {
35958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35959 }
35960 return resultobj;
35961 fail:
35962 return NULL;
35963 }
35964
35965
35966 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35967 PyObject *resultobj = 0;
35968 wxWindow *arg1 = (wxWindow *) 0 ;
35969 void *argp1 = 0 ;
35970 int res1 = 0 ;
35971 PyObject *swig_obj[1] ;
35972
35973 if (!args) SWIG_fail;
35974 swig_obj[0] = args;
35975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35976 if (!SWIG_IsOK(res1)) {
35977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
35978 }
35979 arg1 = reinterpret_cast< wxWindow * >(argp1);
35980 {
35981 PyThreadState* __tstate = wxPyBeginAllowThreads();
35982 (arg1)->SetFocus();
35983 wxPyEndAllowThreads(__tstate);
35984 if (PyErr_Occurred()) SWIG_fail;
35985 }
35986 resultobj = SWIG_Py_Void();
35987 return resultobj;
35988 fail:
35989 return NULL;
35990 }
35991
35992
35993 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35994 PyObject *resultobj = 0;
35995 wxWindow *arg1 = (wxWindow *) 0 ;
35996 void *argp1 = 0 ;
35997 int res1 = 0 ;
35998 PyObject *swig_obj[1] ;
35999
36000 if (!args) SWIG_fail;
36001 swig_obj[0] = args;
36002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36003 if (!SWIG_IsOK(res1)) {
36004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36005 }
36006 arg1 = reinterpret_cast< wxWindow * >(argp1);
36007 {
36008 PyThreadState* __tstate = wxPyBeginAllowThreads();
36009 (arg1)->SetFocusFromKbd();
36010 wxPyEndAllowThreads(__tstate);
36011 if (PyErr_Occurred()) SWIG_fail;
36012 }
36013 resultobj = SWIG_Py_Void();
36014 return resultobj;
36015 fail:
36016 return NULL;
36017 }
36018
36019
36020 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36021 PyObject *resultobj = 0;
36022 wxWindow *result = 0 ;
36023
36024 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36025 {
36026 if (!wxPyCheckForApp()) SWIG_fail;
36027 PyThreadState* __tstate = wxPyBeginAllowThreads();
36028 result = (wxWindow *)wxWindow::FindFocus();
36029 wxPyEndAllowThreads(__tstate);
36030 if (PyErr_Occurred()) SWIG_fail;
36031 }
36032 {
36033 resultobj = wxPyMake_wxObject(result, 0);
36034 }
36035 return resultobj;
36036 fail:
36037 return NULL;
36038 }
36039
36040
36041 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36042 PyObject *resultobj = 0;
36043 wxWindow *arg1 = (wxWindow *) 0 ;
36044 bool result;
36045 void *argp1 = 0 ;
36046 int res1 = 0 ;
36047 PyObject *swig_obj[1] ;
36048
36049 if (!args) SWIG_fail;
36050 swig_obj[0] = args;
36051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36052 if (!SWIG_IsOK(res1)) {
36053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36054 }
36055 arg1 = reinterpret_cast< wxWindow * >(argp1);
36056 {
36057 PyThreadState* __tstate = wxPyBeginAllowThreads();
36058 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36059 wxPyEndAllowThreads(__tstate);
36060 if (PyErr_Occurred()) SWIG_fail;
36061 }
36062 {
36063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36064 }
36065 return resultobj;
36066 fail:
36067 return NULL;
36068 }
36069
36070
36071 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36072 PyObject *resultobj = 0;
36073 wxWindow *arg1 = (wxWindow *) 0 ;
36074 bool result;
36075 void *argp1 = 0 ;
36076 int res1 = 0 ;
36077 PyObject *swig_obj[1] ;
36078
36079 if (!args) SWIG_fail;
36080 swig_obj[0] = args;
36081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36082 if (!SWIG_IsOK(res1)) {
36083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36084 }
36085 arg1 = reinterpret_cast< wxWindow * >(argp1);
36086 {
36087 PyThreadState* __tstate = wxPyBeginAllowThreads();
36088 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36089 wxPyEndAllowThreads(__tstate);
36090 if (PyErr_Occurred()) SWIG_fail;
36091 }
36092 {
36093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36094 }
36095 return resultobj;
36096 fail:
36097 return NULL;
36098 }
36099
36100
36101 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36102 PyObject *resultobj = 0;
36103 wxWindow *arg1 = (wxWindow *) 0 ;
36104 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36105 bool result;
36106 void *argp1 = 0 ;
36107 int res1 = 0 ;
36108 int val2 ;
36109 int ecode2 = 0 ;
36110 PyObject * obj0 = 0 ;
36111 PyObject * obj1 = 0 ;
36112 char * kwnames[] = {
36113 (char *) "self",(char *) "flags", NULL
36114 };
36115
36116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36118 if (!SWIG_IsOK(res1)) {
36119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36120 }
36121 arg1 = reinterpret_cast< wxWindow * >(argp1);
36122 if (obj1) {
36123 ecode2 = SWIG_AsVal_int(obj1, &val2);
36124 if (!SWIG_IsOK(ecode2)) {
36125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36126 }
36127 arg2 = static_cast< int >(val2);
36128 }
36129 {
36130 PyThreadState* __tstate = wxPyBeginAllowThreads();
36131 result = (bool)(arg1)->Navigate(arg2);
36132 wxPyEndAllowThreads(__tstate);
36133 if (PyErr_Occurred()) SWIG_fail;
36134 }
36135 {
36136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36137 }
36138 return resultobj;
36139 fail:
36140 return NULL;
36141 }
36142
36143
36144 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36145 PyObject *resultobj = 0;
36146 wxWindow *arg1 = (wxWindow *) 0 ;
36147 wxWindow *arg2 = (wxWindow *) 0 ;
36148 void *argp1 = 0 ;
36149 int res1 = 0 ;
36150 void *argp2 = 0 ;
36151 int res2 = 0 ;
36152 PyObject * obj0 = 0 ;
36153 PyObject * obj1 = 0 ;
36154 char * kwnames[] = {
36155 (char *) "self",(char *) "win", NULL
36156 };
36157
36158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36160 if (!SWIG_IsOK(res1)) {
36161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36162 }
36163 arg1 = reinterpret_cast< wxWindow * >(argp1);
36164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36165 if (!SWIG_IsOK(res2)) {
36166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36167 }
36168 arg2 = reinterpret_cast< wxWindow * >(argp2);
36169 {
36170 PyThreadState* __tstate = wxPyBeginAllowThreads();
36171 (arg1)->MoveAfterInTabOrder(arg2);
36172 wxPyEndAllowThreads(__tstate);
36173 if (PyErr_Occurred()) SWIG_fail;
36174 }
36175 resultobj = SWIG_Py_Void();
36176 return resultobj;
36177 fail:
36178 return NULL;
36179 }
36180
36181
36182 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36183 PyObject *resultobj = 0;
36184 wxWindow *arg1 = (wxWindow *) 0 ;
36185 wxWindow *arg2 = (wxWindow *) 0 ;
36186 void *argp1 = 0 ;
36187 int res1 = 0 ;
36188 void *argp2 = 0 ;
36189 int res2 = 0 ;
36190 PyObject * obj0 = 0 ;
36191 PyObject * obj1 = 0 ;
36192 char * kwnames[] = {
36193 (char *) "self",(char *) "win", NULL
36194 };
36195
36196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",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_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36200 }
36201 arg1 = reinterpret_cast< wxWindow * >(argp1);
36202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36203 if (!SWIG_IsOK(res2)) {
36204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36205 }
36206 arg2 = reinterpret_cast< wxWindow * >(argp2);
36207 {
36208 PyThreadState* __tstate = wxPyBeginAllowThreads();
36209 (arg1)->MoveBeforeInTabOrder(arg2);
36210 wxPyEndAllowThreads(__tstate);
36211 if (PyErr_Occurred()) SWIG_fail;
36212 }
36213 resultobj = SWIG_Py_Void();
36214 return resultobj;
36215 fail:
36216 return NULL;
36217 }
36218
36219
36220 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36221 PyObject *resultobj = 0;
36222 wxWindow *arg1 = (wxWindow *) 0 ;
36223 PyObject *result = 0 ;
36224 void *argp1 = 0 ;
36225 int res1 = 0 ;
36226 PyObject *swig_obj[1] ;
36227
36228 if (!args) SWIG_fail;
36229 swig_obj[0] = args;
36230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36231 if (!SWIG_IsOK(res1)) {
36232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36233 }
36234 arg1 = reinterpret_cast< wxWindow * >(argp1);
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 result = (PyObject *)wxWindow_GetChildren(arg1);
36238 wxPyEndAllowThreads(__tstate);
36239 if (PyErr_Occurred()) SWIG_fail;
36240 }
36241 resultobj = result;
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36249 PyObject *resultobj = 0;
36250 wxWindow *arg1 = (wxWindow *) 0 ;
36251 wxWindow *result = 0 ;
36252 void *argp1 = 0 ;
36253 int res1 = 0 ;
36254 PyObject *swig_obj[1] ;
36255
36256 if (!args) SWIG_fail;
36257 swig_obj[0] = args;
36258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36259 if (!SWIG_IsOK(res1)) {
36260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36261 }
36262 arg1 = reinterpret_cast< wxWindow * >(argp1);
36263 {
36264 PyThreadState* __tstate = wxPyBeginAllowThreads();
36265 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36266 wxPyEndAllowThreads(__tstate);
36267 if (PyErr_Occurred()) SWIG_fail;
36268 }
36269 {
36270 resultobj = wxPyMake_wxObject(result, 0);
36271 }
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36279 PyObject *resultobj = 0;
36280 wxWindow *arg1 = (wxWindow *) 0 ;
36281 wxWindow *result = 0 ;
36282 void *argp1 = 0 ;
36283 int res1 = 0 ;
36284 PyObject *swig_obj[1] ;
36285
36286 if (!args) SWIG_fail;
36287 swig_obj[0] = args;
36288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36289 if (!SWIG_IsOK(res1)) {
36290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36291 }
36292 arg1 = reinterpret_cast< wxWindow * >(argp1);
36293 {
36294 PyThreadState* __tstate = wxPyBeginAllowThreads();
36295 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36296 wxPyEndAllowThreads(__tstate);
36297 if (PyErr_Occurred()) SWIG_fail;
36298 }
36299 {
36300 resultobj = wxPyMake_wxObject(result, 0);
36301 }
36302 return resultobj;
36303 fail:
36304 return NULL;
36305 }
36306
36307
36308 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36309 PyObject *resultobj = 0;
36310 wxWindow *arg1 = (wxWindow *) 0 ;
36311 bool result;
36312 void *argp1 = 0 ;
36313 int res1 = 0 ;
36314 PyObject *swig_obj[1] ;
36315
36316 if (!args) SWIG_fail;
36317 swig_obj[0] = args;
36318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36319 if (!SWIG_IsOK(res1)) {
36320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36321 }
36322 arg1 = reinterpret_cast< wxWindow * >(argp1);
36323 {
36324 PyThreadState* __tstate = wxPyBeginAllowThreads();
36325 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36326 wxPyEndAllowThreads(__tstate);
36327 if (PyErr_Occurred()) SWIG_fail;
36328 }
36329 {
36330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36331 }
36332 return resultobj;
36333 fail:
36334 return NULL;
36335 }
36336
36337
36338 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36339 PyObject *resultobj = 0;
36340 wxWindow *arg1 = (wxWindow *) 0 ;
36341 wxWindow *arg2 = (wxWindow *) 0 ;
36342 bool result;
36343 void *argp1 = 0 ;
36344 int res1 = 0 ;
36345 void *argp2 = 0 ;
36346 int res2 = 0 ;
36347 PyObject * obj0 = 0 ;
36348 PyObject * obj1 = 0 ;
36349 char * kwnames[] = {
36350 (char *) "self",(char *) "newParent", NULL
36351 };
36352
36353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36355 if (!SWIG_IsOK(res1)) {
36356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36357 }
36358 arg1 = reinterpret_cast< wxWindow * >(argp1);
36359 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36360 if (!SWIG_IsOK(res2)) {
36361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36362 }
36363 arg2 = reinterpret_cast< wxWindow * >(argp2);
36364 {
36365 PyThreadState* __tstate = wxPyBeginAllowThreads();
36366 result = (bool)(arg1)->Reparent(arg2);
36367 wxPyEndAllowThreads(__tstate);
36368 if (PyErr_Occurred()) SWIG_fail;
36369 }
36370 {
36371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36372 }
36373 return resultobj;
36374 fail:
36375 return NULL;
36376 }
36377
36378
36379 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36380 PyObject *resultobj = 0;
36381 wxWindow *arg1 = (wxWindow *) 0 ;
36382 wxWindow *arg2 = (wxWindow *) 0 ;
36383 void *argp1 = 0 ;
36384 int res1 = 0 ;
36385 void *argp2 = 0 ;
36386 int res2 = 0 ;
36387 PyObject * obj0 = 0 ;
36388 PyObject * obj1 = 0 ;
36389 char * kwnames[] = {
36390 (char *) "self",(char *) "child", NULL
36391 };
36392
36393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36395 if (!SWIG_IsOK(res1)) {
36396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36397 }
36398 arg1 = reinterpret_cast< wxWindow * >(argp1);
36399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36400 if (!SWIG_IsOK(res2)) {
36401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36402 }
36403 arg2 = reinterpret_cast< wxWindow * >(argp2);
36404 {
36405 PyThreadState* __tstate = wxPyBeginAllowThreads();
36406 (arg1)->AddChild(arg2);
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 resultobj = SWIG_Py_Void();
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36418 PyObject *resultobj = 0;
36419 wxWindow *arg1 = (wxWindow *) 0 ;
36420 wxWindow *arg2 = (wxWindow *) 0 ;
36421 void *argp1 = 0 ;
36422 int res1 = 0 ;
36423 void *argp2 = 0 ;
36424 int res2 = 0 ;
36425 PyObject * obj0 = 0 ;
36426 PyObject * obj1 = 0 ;
36427 char * kwnames[] = {
36428 (char *) "self",(char *) "child", NULL
36429 };
36430
36431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36433 if (!SWIG_IsOK(res1)) {
36434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36435 }
36436 arg1 = reinterpret_cast< wxWindow * >(argp1);
36437 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36438 if (!SWIG_IsOK(res2)) {
36439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36440 }
36441 arg2 = reinterpret_cast< wxWindow * >(argp2);
36442 {
36443 PyThreadState* __tstate = wxPyBeginAllowThreads();
36444 (arg1)->RemoveChild(arg2);
36445 wxPyEndAllowThreads(__tstate);
36446 if (PyErr_Occurred()) SWIG_fail;
36447 }
36448 resultobj = SWIG_Py_Void();
36449 return resultobj;
36450 fail:
36451 return NULL;
36452 }
36453
36454
36455 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36456 PyObject *resultobj = 0;
36457 wxWindow *arg1 = (wxWindow *) 0 ;
36458 bool arg2 ;
36459 void *argp1 = 0 ;
36460 int res1 = 0 ;
36461 bool val2 ;
36462 int ecode2 = 0 ;
36463 PyObject * obj0 = 0 ;
36464 PyObject * obj1 = 0 ;
36465 char * kwnames[] = {
36466 (char *) "self",(char *) "on", NULL
36467 };
36468
36469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36471 if (!SWIG_IsOK(res1)) {
36472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36473 }
36474 arg1 = reinterpret_cast< wxWindow * >(argp1);
36475 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36476 if (!SWIG_IsOK(ecode2)) {
36477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36478 }
36479 arg2 = static_cast< bool >(val2);
36480 {
36481 PyThreadState* __tstate = wxPyBeginAllowThreads();
36482 wxWindow_SetDoubleBuffered(arg1,arg2);
36483 wxPyEndAllowThreads(__tstate);
36484 if (PyErr_Occurred()) SWIG_fail;
36485 }
36486 resultobj = SWIG_Py_Void();
36487 return resultobj;
36488 fail:
36489 return NULL;
36490 }
36491
36492
36493 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36494 PyObject *resultobj = 0;
36495 wxWindow *arg1 = (wxWindow *) 0 ;
36496 long arg2 ;
36497 wxWindow *result = 0 ;
36498 void *argp1 = 0 ;
36499 int res1 = 0 ;
36500 long val2 ;
36501 int ecode2 = 0 ;
36502 PyObject * obj0 = 0 ;
36503 PyObject * obj1 = 0 ;
36504 char * kwnames[] = {
36505 (char *) "self",(char *) "winid", NULL
36506 };
36507
36508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36510 if (!SWIG_IsOK(res1)) {
36511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36512 }
36513 arg1 = reinterpret_cast< wxWindow * >(argp1);
36514 ecode2 = SWIG_AsVal_long(obj1, &val2);
36515 if (!SWIG_IsOK(ecode2)) {
36516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36517 }
36518 arg2 = static_cast< long >(val2);
36519 {
36520 PyThreadState* __tstate = wxPyBeginAllowThreads();
36521 result = (wxWindow *)(arg1)->FindWindow(arg2);
36522 wxPyEndAllowThreads(__tstate);
36523 if (PyErr_Occurred()) SWIG_fail;
36524 }
36525 {
36526 resultobj = wxPyMake_wxObject(result, 0);
36527 }
36528 return resultobj;
36529 fail:
36530 return NULL;
36531 }
36532
36533
36534 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36535 PyObject *resultobj = 0;
36536 wxWindow *arg1 = (wxWindow *) 0 ;
36537 wxString *arg2 = 0 ;
36538 wxWindow *result = 0 ;
36539 void *argp1 = 0 ;
36540 int res1 = 0 ;
36541 bool temp2 = false ;
36542 PyObject * obj0 = 0 ;
36543 PyObject * obj1 = 0 ;
36544 char * kwnames[] = {
36545 (char *) "self",(char *) "name", NULL
36546 };
36547
36548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36550 if (!SWIG_IsOK(res1)) {
36551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36552 }
36553 arg1 = reinterpret_cast< wxWindow * >(argp1);
36554 {
36555 arg2 = wxString_in_helper(obj1);
36556 if (arg2 == NULL) SWIG_fail;
36557 temp2 = true;
36558 }
36559 {
36560 PyThreadState* __tstate = wxPyBeginAllowThreads();
36561 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36562 wxPyEndAllowThreads(__tstate);
36563 if (PyErr_Occurred()) SWIG_fail;
36564 }
36565 {
36566 resultobj = wxPyMake_wxObject(result, 0);
36567 }
36568 {
36569 if (temp2)
36570 delete arg2;
36571 }
36572 return resultobj;
36573 fail:
36574 {
36575 if (temp2)
36576 delete arg2;
36577 }
36578 return NULL;
36579 }
36580
36581
36582 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36583 PyObject *resultobj = 0;
36584 wxWindow *arg1 = (wxWindow *) 0 ;
36585 wxEvtHandler *result = 0 ;
36586 void *argp1 = 0 ;
36587 int res1 = 0 ;
36588 PyObject *swig_obj[1] ;
36589
36590 if (!args) SWIG_fail;
36591 swig_obj[0] = args;
36592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36593 if (!SWIG_IsOK(res1)) {
36594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36595 }
36596 arg1 = reinterpret_cast< wxWindow * >(argp1);
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36600 wxPyEndAllowThreads(__tstate);
36601 if (PyErr_Occurred()) SWIG_fail;
36602 }
36603 {
36604 resultobj = wxPyMake_wxObject(result, 0);
36605 }
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36613 PyObject *resultobj = 0;
36614 wxWindow *arg1 = (wxWindow *) 0 ;
36615 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 void *argp2 = 0 ;
36619 int res2 = 0 ;
36620 PyObject * obj0 = 0 ;
36621 PyObject * obj1 = 0 ;
36622 char * kwnames[] = {
36623 (char *) "self",(char *) "handler", NULL
36624 };
36625
36626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36628 if (!SWIG_IsOK(res1)) {
36629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36630 }
36631 arg1 = reinterpret_cast< wxWindow * >(argp1);
36632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36633 if (!SWIG_IsOK(res2)) {
36634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36635 }
36636 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36637 {
36638 PyThreadState* __tstate = wxPyBeginAllowThreads();
36639 (arg1)->SetEventHandler(arg2);
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 resultobj = SWIG_Py_Void();
36644 return resultobj;
36645 fail:
36646 return NULL;
36647 }
36648
36649
36650 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36651 PyObject *resultobj = 0;
36652 wxWindow *arg1 = (wxWindow *) 0 ;
36653 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36654 void *argp1 = 0 ;
36655 int res1 = 0 ;
36656 void *argp2 = 0 ;
36657 int res2 = 0 ;
36658 PyObject * obj0 = 0 ;
36659 PyObject * obj1 = 0 ;
36660 char * kwnames[] = {
36661 (char *) "self",(char *) "handler", NULL
36662 };
36663
36664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36666 if (!SWIG_IsOK(res1)) {
36667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36668 }
36669 arg1 = reinterpret_cast< wxWindow * >(argp1);
36670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36671 if (!SWIG_IsOK(res2)) {
36672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36673 }
36674 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36675 {
36676 PyThreadState* __tstate = wxPyBeginAllowThreads();
36677 (arg1)->PushEventHandler(arg2);
36678 wxPyEndAllowThreads(__tstate);
36679 if (PyErr_Occurred()) SWIG_fail;
36680 }
36681 resultobj = SWIG_Py_Void();
36682 return resultobj;
36683 fail:
36684 return NULL;
36685 }
36686
36687
36688 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36689 PyObject *resultobj = 0;
36690 wxWindow *arg1 = (wxWindow *) 0 ;
36691 bool arg2 = (bool) false ;
36692 wxEvtHandler *result = 0 ;
36693 void *argp1 = 0 ;
36694 int res1 = 0 ;
36695 bool val2 ;
36696 int ecode2 = 0 ;
36697 PyObject * obj0 = 0 ;
36698 PyObject * obj1 = 0 ;
36699 char * kwnames[] = {
36700 (char *) "self",(char *) "deleteHandler", NULL
36701 };
36702
36703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36705 if (!SWIG_IsOK(res1)) {
36706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36707 }
36708 arg1 = reinterpret_cast< wxWindow * >(argp1);
36709 if (obj1) {
36710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36711 if (!SWIG_IsOK(ecode2)) {
36712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36713 }
36714 arg2 = static_cast< bool >(val2);
36715 }
36716 {
36717 PyThreadState* __tstate = wxPyBeginAllowThreads();
36718 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36719 wxPyEndAllowThreads(__tstate);
36720 if (PyErr_Occurred()) SWIG_fail;
36721 }
36722 {
36723 resultobj = wxPyMake_wxObject(result, 0);
36724 }
36725 return resultobj;
36726 fail:
36727 return NULL;
36728 }
36729
36730
36731 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36732 PyObject *resultobj = 0;
36733 wxWindow *arg1 = (wxWindow *) 0 ;
36734 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36735 bool result;
36736 void *argp1 = 0 ;
36737 int res1 = 0 ;
36738 void *argp2 = 0 ;
36739 int res2 = 0 ;
36740 PyObject * obj0 = 0 ;
36741 PyObject * obj1 = 0 ;
36742 char * kwnames[] = {
36743 (char *) "self",(char *) "handler", NULL
36744 };
36745
36746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36748 if (!SWIG_IsOK(res1)) {
36749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36750 }
36751 arg1 = reinterpret_cast< wxWindow * >(argp1);
36752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36753 if (!SWIG_IsOK(res2)) {
36754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36755 }
36756 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36757 {
36758 PyThreadState* __tstate = wxPyBeginAllowThreads();
36759 result = (bool)(arg1)->RemoveEventHandler(arg2);
36760 wxPyEndAllowThreads(__tstate);
36761 if (PyErr_Occurred()) SWIG_fail;
36762 }
36763 {
36764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36765 }
36766 return resultobj;
36767 fail:
36768 return NULL;
36769 }
36770
36771
36772 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36773 PyObject *resultobj = 0;
36774 wxWindow *arg1 = (wxWindow *) 0 ;
36775 wxValidator *arg2 = 0 ;
36776 void *argp1 = 0 ;
36777 int res1 = 0 ;
36778 void *argp2 = 0 ;
36779 int res2 = 0 ;
36780 PyObject * obj0 = 0 ;
36781 PyObject * obj1 = 0 ;
36782 char * kwnames[] = {
36783 (char *) "self",(char *) "validator", NULL
36784 };
36785
36786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36788 if (!SWIG_IsOK(res1)) {
36789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36790 }
36791 arg1 = reinterpret_cast< wxWindow * >(argp1);
36792 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36793 if (!SWIG_IsOK(res2)) {
36794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36795 }
36796 if (!argp2) {
36797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36798 }
36799 arg2 = reinterpret_cast< wxValidator * >(argp2);
36800 {
36801 PyThreadState* __tstate = wxPyBeginAllowThreads();
36802 (arg1)->SetValidator((wxValidator const &)*arg2);
36803 wxPyEndAllowThreads(__tstate);
36804 if (PyErr_Occurred()) SWIG_fail;
36805 }
36806 resultobj = SWIG_Py_Void();
36807 return resultobj;
36808 fail:
36809 return NULL;
36810 }
36811
36812
36813 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36814 PyObject *resultobj = 0;
36815 wxWindow *arg1 = (wxWindow *) 0 ;
36816 wxValidator *result = 0 ;
36817 void *argp1 = 0 ;
36818 int res1 = 0 ;
36819 PyObject *swig_obj[1] ;
36820
36821 if (!args) SWIG_fail;
36822 swig_obj[0] = args;
36823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36824 if (!SWIG_IsOK(res1)) {
36825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36826 }
36827 arg1 = reinterpret_cast< wxWindow * >(argp1);
36828 {
36829 PyThreadState* __tstate = wxPyBeginAllowThreads();
36830 result = (wxValidator *)(arg1)->GetValidator();
36831 wxPyEndAllowThreads(__tstate);
36832 if (PyErr_Occurred()) SWIG_fail;
36833 }
36834 {
36835 resultobj = wxPyMake_wxObject(result, (bool)0);
36836 }
36837 return resultobj;
36838 fail:
36839 return NULL;
36840 }
36841
36842
36843 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36844 PyObject *resultobj = 0;
36845 wxWindow *arg1 = (wxWindow *) 0 ;
36846 bool result;
36847 void *argp1 = 0 ;
36848 int res1 = 0 ;
36849 PyObject *swig_obj[1] ;
36850
36851 if (!args) SWIG_fail;
36852 swig_obj[0] = args;
36853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36854 if (!SWIG_IsOK(res1)) {
36855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36856 }
36857 arg1 = reinterpret_cast< wxWindow * >(argp1);
36858 {
36859 PyThreadState* __tstate = wxPyBeginAllowThreads();
36860 result = (bool)(arg1)->Validate();
36861 wxPyEndAllowThreads(__tstate);
36862 if (PyErr_Occurred()) SWIG_fail;
36863 }
36864 {
36865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36866 }
36867 return resultobj;
36868 fail:
36869 return NULL;
36870 }
36871
36872
36873 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36874 PyObject *resultobj = 0;
36875 wxWindow *arg1 = (wxWindow *) 0 ;
36876 bool result;
36877 void *argp1 = 0 ;
36878 int res1 = 0 ;
36879 PyObject *swig_obj[1] ;
36880
36881 if (!args) SWIG_fail;
36882 swig_obj[0] = args;
36883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36884 if (!SWIG_IsOK(res1)) {
36885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36886 }
36887 arg1 = reinterpret_cast< wxWindow * >(argp1);
36888 {
36889 PyThreadState* __tstate = wxPyBeginAllowThreads();
36890 result = (bool)(arg1)->TransferDataToWindow();
36891 wxPyEndAllowThreads(__tstate);
36892 if (PyErr_Occurred()) SWIG_fail;
36893 }
36894 {
36895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36896 }
36897 return resultobj;
36898 fail:
36899 return NULL;
36900 }
36901
36902
36903 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36904 PyObject *resultobj = 0;
36905 wxWindow *arg1 = (wxWindow *) 0 ;
36906 bool result;
36907 void *argp1 = 0 ;
36908 int res1 = 0 ;
36909 PyObject *swig_obj[1] ;
36910
36911 if (!args) SWIG_fail;
36912 swig_obj[0] = args;
36913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36914 if (!SWIG_IsOK(res1)) {
36915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36916 }
36917 arg1 = reinterpret_cast< wxWindow * >(argp1);
36918 {
36919 PyThreadState* __tstate = wxPyBeginAllowThreads();
36920 result = (bool)(arg1)->TransferDataFromWindow();
36921 wxPyEndAllowThreads(__tstate);
36922 if (PyErr_Occurred()) SWIG_fail;
36923 }
36924 {
36925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36926 }
36927 return resultobj;
36928 fail:
36929 return NULL;
36930 }
36931
36932
36933 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36934 PyObject *resultobj = 0;
36935 wxWindow *arg1 = (wxWindow *) 0 ;
36936 void *argp1 = 0 ;
36937 int res1 = 0 ;
36938 PyObject *swig_obj[1] ;
36939
36940 if (!args) SWIG_fail;
36941 swig_obj[0] = args;
36942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36943 if (!SWIG_IsOK(res1)) {
36944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
36945 }
36946 arg1 = reinterpret_cast< wxWindow * >(argp1);
36947 {
36948 PyThreadState* __tstate = wxPyBeginAllowThreads();
36949 (arg1)->InitDialog();
36950 wxPyEndAllowThreads(__tstate);
36951 if (PyErr_Occurred()) SWIG_fail;
36952 }
36953 resultobj = SWIG_Py_Void();
36954 return resultobj;
36955 fail:
36956 return NULL;
36957 }
36958
36959
36960 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36961 PyObject *resultobj = 0;
36962 wxWindow *arg1 = (wxWindow *) 0 ;
36963 wxAcceleratorTable *arg2 = 0 ;
36964 void *argp1 = 0 ;
36965 int res1 = 0 ;
36966 void *argp2 = 0 ;
36967 int res2 = 0 ;
36968 PyObject * obj0 = 0 ;
36969 PyObject * obj1 = 0 ;
36970 char * kwnames[] = {
36971 (char *) "self",(char *) "accel", NULL
36972 };
36973
36974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
36975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36976 if (!SWIG_IsOK(res1)) {
36977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
36978 }
36979 arg1 = reinterpret_cast< wxWindow * >(argp1);
36980 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
36981 if (!SWIG_IsOK(res2)) {
36982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
36983 }
36984 if (!argp2) {
36985 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
36986 }
36987 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
36988 {
36989 PyThreadState* __tstate = wxPyBeginAllowThreads();
36990 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
36991 wxPyEndAllowThreads(__tstate);
36992 if (PyErr_Occurred()) SWIG_fail;
36993 }
36994 resultobj = SWIG_Py_Void();
36995 return resultobj;
36996 fail:
36997 return NULL;
36998 }
36999
37000
37001 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37002 PyObject *resultobj = 0;
37003 wxWindow *arg1 = (wxWindow *) 0 ;
37004 wxAcceleratorTable *result = 0 ;
37005 void *argp1 = 0 ;
37006 int res1 = 0 ;
37007 PyObject *swig_obj[1] ;
37008
37009 if (!args) SWIG_fail;
37010 swig_obj[0] = args;
37011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37012 if (!SWIG_IsOK(res1)) {
37013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37014 }
37015 arg1 = reinterpret_cast< wxWindow * >(argp1);
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37019 wxPyEndAllowThreads(__tstate);
37020 if (PyErr_Occurred()) SWIG_fail;
37021 }
37022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37023 return resultobj;
37024 fail:
37025 return NULL;
37026 }
37027
37028
37029 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37030 PyObject *resultobj = 0;
37031 wxWindow *arg1 = (wxWindow *) 0 ;
37032 int arg2 ;
37033 int arg3 ;
37034 int arg4 ;
37035 bool result;
37036 void *argp1 = 0 ;
37037 int res1 = 0 ;
37038 int val2 ;
37039 int ecode2 = 0 ;
37040 int val3 ;
37041 int ecode3 = 0 ;
37042 int val4 ;
37043 int ecode4 = 0 ;
37044 PyObject * obj0 = 0 ;
37045 PyObject * obj1 = 0 ;
37046 PyObject * obj2 = 0 ;
37047 PyObject * obj3 = 0 ;
37048 char * kwnames[] = {
37049 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37050 };
37051
37052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37054 if (!SWIG_IsOK(res1)) {
37055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37056 }
37057 arg1 = reinterpret_cast< wxWindow * >(argp1);
37058 ecode2 = SWIG_AsVal_int(obj1, &val2);
37059 if (!SWIG_IsOK(ecode2)) {
37060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37061 }
37062 arg2 = static_cast< int >(val2);
37063 ecode3 = SWIG_AsVal_int(obj2, &val3);
37064 if (!SWIG_IsOK(ecode3)) {
37065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37066 }
37067 arg3 = static_cast< int >(val3);
37068 ecode4 = SWIG_AsVal_int(obj3, &val4);
37069 if (!SWIG_IsOK(ecode4)) {
37070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37071 }
37072 arg4 = static_cast< int >(val4);
37073 {
37074 PyThreadState* __tstate = wxPyBeginAllowThreads();
37075 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37076 wxPyEndAllowThreads(__tstate);
37077 if (PyErr_Occurred()) SWIG_fail;
37078 }
37079 {
37080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37081 }
37082 return resultobj;
37083 fail:
37084 return NULL;
37085 }
37086
37087
37088 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37089 PyObject *resultobj = 0;
37090 wxWindow *arg1 = (wxWindow *) 0 ;
37091 int arg2 ;
37092 bool result;
37093 void *argp1 = 0 ;
37094 int res1 = 0 ;
37095 int val2 ;
37096 int ecode2 = 0 ;
37097 PyObject * obj0 = 0 ;
37098 PyObject * obj1 = 0 ;
37099 char * kwnames[] = {
37100 (char *) "self",(char *) "hotkeyId", NULL
37101 };
37102
37103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37105 if (!SWIG_IsOK(res1)) {
37106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37107 }
37108 arg1 = reinterpret_cast< wxWindow * >(argp1);
37109 ecode2 = SWIG_AsVal_int(obj1, &val2);
37110 if (!SWIG_IsOK(ecode2)) {
37111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37112 }
37113 arg2 = static_cast< int >(val2);
37114 {
37115 PyThreadState* __tstate = wxPyBeginAllowThreads();
37116 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37117 wxPyEndAllowThreads(__tstate);
37118 if (PyErr_Occurred()) SWIG_fail;
37119 }
37120 {
37121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37122 }
37123 return resultobj;
37124 fail:
37125 return NULL;
37126 }
37127
37128
37129 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37130 PyObject *resultobj = 0;
37131 wxWindow *arg1 = (wxWindow *) 0 ;
37132 wxPoint *arg2 = 0 ;
37133 wxPoint result;
37134 void *argp1 = 0 ;
37135 int res1 = 0 ;
37136 wxPoint temp2 ;
37137 PyObject * obj0 = 0 ;
37138 PyObject * obj1 = 0 ;
37139 char * kwnames[] = {
37140 (char *) "self",(char *) "pt", NULL
37141 };
37142
37143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37145 if (!SWIG_IsOK(res1)) {
37146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37147 }
37148 arg1 = reinterpret_cast< wxWindow * >(argp1);
37149 {
37150 arg2 = &temp2;
37151 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37152 }
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37160 return resultobj;
37161 fail:
37162 return NULL;
37163 }
37164
37165
37166 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37167 PyObject *resultobj = 0;
37168 wxWindow *arg1 = (wxWindow *) 0 ;
37169 wxSize *arg2 = 0 ;
37170 wxSize result;
37171 void *argp1 = 0 ;
37172 int res1 = 0 ;
37173 wxSize temp2 ;
37174 PyObject * obj0 = 0 ;
37175 PyObject * obj1 = 0 ;
37176 char * kwnames[] = {
37177 (char *) "self",(char *) "sz", NULL
37178 };
37179
37180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37182 if (!SWIG_IsOK(res1)) {
37183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37184 }
37185 arg1 = reinterpret_cast< wxWindow * >(argp1);
37186 {
37187 arg2 = &temp2;
37188 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37189 }
37190 {
37191 PyThreadState* __tstate = wxPyBeginAllowThreads();
37192 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37193 wxPyEndAllowThreads(__tstate);
37194 if (PyErr_Occurred()) SWIG_fail;
37195 }
37196 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37197 return resultobj;
37198 fail:
37199 return NULL;
37200 }
37201
37202
37203 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37204 PyObject *resultobj = 0;
37205 wxWindow *arg1 = (wxWindow *) 0 ;
37206 wxPoint *arg2 = 0 ;
37207 wxPoint result;
37208 void *argp1 = 0 ;
37209 int res1 = 0 ;
37210 wxPoint temp2 ;
37211 PyObject * obj0 = 0 ;
37212 PyObject * obj1 = 0 ;
37213 char * kwnames[] = {
37214 (char *) "self",(char *) "pt", NULL
37215 };
37216
37217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37219 if (!SWIG_IsOK(res1)) {
37220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37221 }
37222 arg1 = reinterpret_cast< wxWindow * >(argp1);
37223 {
37224 arg2 = &temp2;
37225 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37226 }
37227 {
37228 PyThreadState* __tstate = wxPyBeginAllowThreads();
37229 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37230 wxPyEndAllowThreads(__tstate);
37231 if (PyErr_Occurred()) SWIG_fail;
37232 }
37233 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37234 return resultobj;
37235 fail:
37236 return NULL;
37237 }
37238
37239
37240 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37241 PyObject *resultobj = 0;
37242 wxWindow *arg1 = (wxWindow *) 0 ;
37243 wxSize *arg2 = 0 ;
37244 wxSize result;
37245 void *argp1 = 0 ;
37246 int res1 = 0 ;
37247 wxSize temp2 ;
37248 PyObject * obj0 = 0 ;
37249 PyObject * obj1 = 0 ;
37250 char * kwnames[] = {
37251 (char *) "self",(char *) "sz", NULL
37252 };
37253
37254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37256 if (!SWIG_IsOK(res1)) {
37257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37258 }
37259 arg1 = reinterpret_cast< wxWindow * >(argp1);
37260 {
37261 arg2 = &temp2;
37262 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37263 }
37264 {
37265 PyThreadState* __tstate = wxPyBeginAllowThreads();
37266 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37267 wxPyEndAllowThreads(__tstate);
37268 if (PyErr_Occurred()) SWIG_fail;
37269 }
37270 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37271 return resultobj;
37272 fail:
37273 return NULL;
37274 }
37275
37276
37277 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37278 PyObject *resultobj = 0;
37279 wxWindow *arg1 = (wxWindow *) 0 ;
37280 wxPoint *arg2 = 0 ;
37281 wxPoint result;
37282 void *argp1 = 0 ;
37283 int res1 = 0 ;
37284 wxPoint temp2 ;
37285 PyObject * obj0 = 0 ;
37286 PyObject * obj1 = 0 ;
37287 char * kwnames[] = {
37288 (char *) "self",(char *) "pt", NULL
37289 };
37290
37291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37293 if (!SWIG_IsOK(res1)) {
37294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37295 }
37296 arg1 = reinterpret_cast< wxWindow * >(argp1);
37297 {
37298 arg2 = &temp2;
37299 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37300 }
37301 {
37302 PyThreadState* __tstate = wxPyBeginAllowThreads();
37303 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37304 wxPyEndAllowThreads(__tstate);
37305 if (PyErr_Occurred()) SWIG_fail;
37306 }
37307 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37308 return resultobj;
37309 fail:
37310 return NULL;
37311 }
37312
37313
37314 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37315 PyObject *resultobj = 0;
37316 wxWindow *arg1 = (wxWindow *) 0 ;
37317 wxSize *arg2 = 0 ;
37318 wxSize result;
37319 void *argp1 = 0 ;
37320 int res1 = 0 ;
37321 wxSize temp2 ;
37322 PyObject * obj0 = 0 ;
37323 PyObject * obj1 = 0 ;
37324 char * kwnames[] = {
37325 (char *) "self",(char *) "sz", NULL
37326 };
37327
37328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37330 if (!SWIG_IsOK(res1)) {
37331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37332 }
37333 arg1 = reinterpret_cast< wxWindow * >(argp1);
37334 {
37335 arg2 = &temp2;
37336 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37337 }
37338 {
37339 PyThreadState* __tstate = wxPyBeginAllowThreads();
37340 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37341 wxPyEndAllowThreads(__tstate);
37342 if (PyErr_Occurred()) SWIG_fail;
37343 }
37344 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37345 return resultobj;
37346 fail:
37347 return NULL;
37348 }
37349
37350
37351 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37352 PyObject *resultobj = 0;
37353 wxWindow *arg1 = (wxWindow *) 0 ;
37354 int arg2 ;
37355 int arg3 ;
37356 void *argp1 = 0 ;
37357 int res1 = 0 ;
37358 int val2 ;
37359 int ecode2 = 0 ;
37360 int val3 ;
37361 int ecode3 = 0 ;
37362 PyObject * obj0 = 0 ;
37363 PyObject * obj1 = 0 ;
37364 PyObject * obj2 = 0 ;
37365 char * kwnames[] = {
37366 (char *) "self",(char *) "x",(char *) "y", NULL
37367 };
37368
37369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37371 if (!SWIG_IsOK(res1)) {
37372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37373 }
37374 arg1 = reinterpret_cast< wxWindow * >(argp1);
37375 ecode2 = SWIG_AsVal_int(obj1, &val2);
37376 if (!SWIG_IsOK(ecode2)) {
37377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37378 }
37379 arg2 = static_cast< int >(val2);
37380 ecode3 = SWIG_AsVal_int(obj2, &val3);
37381 if (!SWIG_IsOK(ecode3)) {
37382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37383 }
37384 arg3 = static_cast< int >(val3);
37385 {
37386 PyThreadState* __tstate = wxPyBeginAllowThreads();
37387 (arg1)->WarpPointer(arg2,arg3);
37388 wxPyEndAllowThreads(__tstate);
37389 if (PyErr_Occurred()) SWIG_fail;
37390 }
37391 resultobj = SWIG_Py_Void();
37392 return resultobj;
37393 fail:
37394 return NULL;
37395 }
37396
37397
37398 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37399 PyObject *resultobj = 0;
37400 wxWindow *arg1 = (wxWindow *) 0 ;
37401 void *argp1 = 0 ;
37402 int res1 = 0 ;
37403 PyObject *swig_obj[1] ;
37404
37405 if (!args) SWIG_fail;
37406 swig_obj[0] = args;
37407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37408 if (!SWIG_IsOK(res1)) {
37409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37410 }
37411 arg1 = reinterpret_cast< wxWindow * >(argp1);
37412 {
37413 PyThreadState* __tstate = wxPyBeginAllowThreads();
37414 (arg1)->CaptureMouse();
37415 wxPyEndAllowThreads(__tstate);
37416 if (PyErr_Occurred()) SWIG_fail;
37417 }
37418 resultobj = SWIG_Py_Void();
37419 return resultobj;
37420 fail:
37421 return NULL;
37422 }
37423
37424
37425 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37426 PyObject *resultobj = 0;
37427 wxWindow *arg1 = (wxWindow *) 0 ;
37428 void *argp1 = 0 ;
37429 int res1 = 0 ;
37430 PyObject *swig_obj[1] ;
37431
37432 if (!args) SWIG_fail;
37433 swig_obj[0] = args;
37434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37435 if (!SWIG_IsOK(res1)) {
37436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37437 }
37438 arg1 = reinterpret_cast< wxWindow * >(argp1);
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 (arg1)->ReleaseMouse();
37442 wxPyEndAllowThreads(__tstate);
37443 if (PyErr_Occurred()) SWIG_fail;
37444 }
37445 resultobj = SWIG_Py_Void();
37446 return resultobj;
37447 fail:
37448 return NULL;
37449 }
37450
37451
37452 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37453 PyObject *resultobj = 0;
37454 wxWindow *result = 0 ;
37455
37456 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37457 {
37458 if (!wxPyCheckForApp()) SWIG_fail;
37459 PyThreadState* __tstate = wxPyBeginAllowThreads();
37460 result = (wxWindow *)wxWindow::GetCapture();
37461 wxPyEndAllowThreads(__tstate);
37462 if (PyErr_Occurred()) SWIG_fail;
37463 }
37464 {
37465 resultobj = wxPyMake_wxObject(result, 0);
37466 }
37467 return resultobj;
37468 fail:
37469 return NULL;
37470 }
37471
37472
37473 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37474 PyObject *resultobj = 0;
37475 wxWindow *arg1 = (wxWindow *) 0 ;
37476 bool result;
37477 void *argp1 = 0 ;
37478 int res1 = 0 ;
37479 PyObject *swig_obj[1] ;
37480
37481 if (!args) SWIG_fail;
37482 swig_obj[0] = args;
37483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37484 if (!SWIG_IsOK(res1)) {
37485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37486 }
37487 arg1 = reinterpret_cast< wxWindow * >(argp1);
37488 {
37489 PyThreadState* __tstate = wxPyBeginAllowThreads();
37490 result = (bool)((wxWindow const *)arg1)->HasCapture();
37491 wxPyEndAllowThreads(__tstate);
37492 if (PyErr_Occurred()) SWIG_fail;
37493 }
37494 {
37495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37496 }
37497 return resultobj;
37498 fail:
37499 return NULL;
37500 }
37501
37502
37503 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37504 PyObject *resultobj = 0;
37505 wxWindow *arg1 = (wxWindow *) 0 ;
37506 bool arg2 = (bool) true ;
37507 wxRect *arg3 = (wxRect *) NULL ;
37508 void *argp1 = 0 ;
37509 int res1 = 0 ;
37510 bool val2 ;
37511 int ecode2 = 0 ;
37512 void *argp3 = 0 ;
37513 int res3 = 0 ;
37514 PyObject * obj0 = 0 ;
37515 PyObject * obj1 = 0 ;
37516 PyObject * obj2 = 0 ;
37517 char * kwnames[] = {
37518 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37519 };
37520
37521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37523 if (!SWIG_IsOK(res1)) {
37524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37525 }
37526 arg1 = reinterpret_cast< wxWindow * >(argp1);
37527 if (obj1) {
37528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37529 if (!SWIG_IsOK(ecode2)) {
37530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37531 }
37532 arg2 = static_cast< bool >(val2);
37533 }
37534 if (obj2) {
37535 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37536 if (!SWIG_IsOK(res3)) {
37537 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37538 }
37539 arg3 = reinterpret_cast< wxRect * >(argp3);
37540 }
37541 {
37542 PyThreadState* __tstate = wxPyBeginAllowThreads();
37543 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37544 wxPyEndAllowThreads(__tstate);
37545 if (PyErr_Occurred()) SWIG_fail;
37546 }
37547 resultobj = SWIG_Py_Void();
37548 return resultobj;
37549 fail:
37550 return NULL;
37551 }
37552
37553
37554 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37555 PyObject *resultobj = 0;
37556 wxWindow *arg1 = (wxWindow *) 0 ;
37557 wxRect *arg2 = 0 ;
37558 bool arg3 = (bool) true ;
37559 void *argp1 = 0 ;
37560 int res1 = 0 ;
37561 wxRect temp2 ;
37562 bool val3 ;
37563 int ecode3 = 0 ;
37564 PyObject * obj0 = 0 ;
37565 PyObject * obj1 = 0 ;
37566 PyObject * obj2 = 0 ;
37567 char * kwnames[] = {
37568 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37569 };
37570
37571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37573 if (!SWIG_IsOK(res1)) {
37574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37575 }
37576 arg1 = reinterpret_cast< wxWindow * >(argp1);
37577 {
37578 arg2 = &temp2;
37579 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37580 }
37581 if (obj2) {
37582 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37583 if (!SWIG_IsOK(ecode3)) {
37584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37585 }
37586 arg3 = static_cast< bool >(val3);
37587 }
37588 {
37589 PyThreadState* __tstate = wxPyBeginAllowThreads();
37590 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37591 wxPyEndAllowThreads(__tstate);
37592 if (PyErr_Occurred()) SWIG_fail;
37593 }
37594 resultobj = SWIG_Py_Void();
37595 return resultobj;
37596 fail:
37597 return NULL;
37598 }
37599
37600
37601 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37602 PyObject *resultobj = 0;
37603 wxWindow *arg1 = (wxWindow *) 0 ;
37604 void *argp1 = 0 ;
37605 int res1 = 0 ;
37606 PyObject *swig_obj[1] ;
37607
37608 if (!args) SWIG_fail;
37609 swig_obj[0] = args;
37610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37611 if (!SWIG_IsOK(res1)) {
37612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37613 }
37614 arg1 = reinterpret_cast< wxWindow * >(argp1);
37615 {
37616 PyThreadState* __tstate = wxPyBeginAllowThreads();
37617 (arg1)->Update();
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 resultobj = SWIG_Py_Void();
37622 return resultobj;
37623 fail:
37624 return NULL;
37625 }
37626
37627
37628 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37629 PyObject *resultobj = 0;
37630 wxWindow *arg1 = (wxWindow *) 0 ;
37631 void *argp1 = 0 ;
37632 int res1 = 0 ;
37633 PyObject *swig_obj[1] ;
37634
37635 if (!args) SWIG_fail;
37636 swig_obj[0] = args;
37637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37638 if (!SWIG_IsOK(res1)) {
37639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37640 }
37641 arg1 = reinterpret_cast< wxWindow * >(argp1);
37642 {
37643 PyThreadState* __tstate = wxPyBeginAllowThreads();
37644 (arg1)->ClearBackground();
37645 wxPyEndAllowThreads(__tstate);
37646 if (PyErr_Occurred()) SWIG_fail;
37647 }
37648 resultobj = SWIG_Py_Void();
37649 return resultobj;
37650 fail:
37651 return NULL;
37652 }
37653
37654
37655 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37656 PyObject *resultobj = 0;
37657 wxWindow *arg1 = (wxWindow *) 0 ;
37658 void *argp1 = 0 ;
37659 int res1 = 0 ;
37660 PyObject *swig_obj[1] ;
37661
37662 if (!args) SWIG_fail;
37663 swig_obj[0] = args;
37664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37665 if (!SWIG_IsOK(res1)) {
37666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37667 }
37668 arg1 = reinterpret_cast< wxWindow * >(argp1);
37669 {
37670 PyThreadState* __tstate = wxPyBeginAllowThreads();
37671 (arg1)->Freeze();
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 resultobj = SWIG_Py_Void();
37676 return resultobj;
37677 fail:
37678 return NULL;
37679 }
37680
37681
37682 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37683 PyObject *resultobj = 0;
37684 wxWindow *arg1 = (wxWindow *) 0 ;
37685 bool result;
37686 void *argp1 = 0 ;
37687 int res1 = 0 ;
37688 PyObject *swig_obj[1] ;
37689
37690 if (!args) SWIG_fail;
37691 swig_obj[0] = args;
37692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37693 if (!SWIG_IsOK(res1)) {
37694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37695 }
37696 arg1 = reinterpret_cast< wxWindow * >(argp1);
37697 {
37698 PyThreadState* __tstate = wxPyBeginAllowThreads();
37699 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37700 wxPyEndAllowThreads(__tstate);
37701 if (PyErr_Occurred()) SWIG_fail;
37702 }
37703 {
37704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37705 }
37706 return resultobj;
37707 fail:
37708 return NULL;
37709 }
37710
37711
37712 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37713 PyObject *resultobj = 0;
37714 wxWindow *arg1 = (wxWindow *) 0 ;
37715 void *argp1 = 0 ;
37716 int res1 = 0 ;
37717 PyObject *swig_obj[1] ;
37718
37719 if (!args) SWIG_fail;
37720 swig_obj[0] = args;
37721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37722 if (!SWIG_IsOK(res1)) {
37723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37724 }
37725 arg1 = reinterpret_cast< wxWindow * >(argp1);
37726 {
37727 PyThreadState* __tstate = wxPyBeginAllowThreads();
37728 (arg1)->Thaw();
37729 wxPyEndAllowThreads(__tstate);
37730 if (PyErr_Occurred()) SWIG_fail;
37731 }
37732 resultobj = SWIG_Py_Void();
37733 return resultobj;
37734 fail:
37735 return NULL;
37736 }
37737
37738
37739 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37740 PyObject *resultobj = 0;
37741 wxWindow *arg1 = (wxWindow *) 0 ;
37742 wxDC *arg2 = 0 ;
37743 void *argp1 = 0 ;
37744 int res1 = 0 ;
37745 void *argp2 = 0 ;
37746 int res2 = 0 ;
37747 PyObject * obj0 = 0 ;
37748 PyObject * obj1 = 0 ;
37749 char * kwnames[] = {
37750 (char *) "self",(char *) "dc", NULL
37751 };
37752
37753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37755 if (!SWIG_IsOK(res1)) {
37756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37757 }
37758 arg1 = reinterpret_cast< wxWindow * >(argp1);
37759 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37760 if (!SWIG_IsOK(res2)) {
37761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37762 }
37763 if (!argp2) {
37764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37765 }
37766 arg2 = reinterpret_cast< wxDC * >(argp2);
37767 {
37768 PyThreadState* __tstate = wxPyBeginAllowThreads();
37769 (arg1)->PrepareDC(*arg2);
37770 wxPyEndAllowThreads(__tstate);
37771 if (PyErr_Occurred()) SWIG_fail;
37772 }
37773 resultobj = SWIG_Py_Void();
37774 return resultobj;
37775 fail:
37776 return NULL;
37777 }
37778
37779
37780 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37781 PyObject *resultobj = 0;
37782 wxWindow *arg1 = (wxWindow *) 0 ;
37783 bool result;
37784 void *argp1 = 0 ;
37785 int res1 = 0 ;
37786 PyObject *swig_obj[1] ;
37787
37788 if (!args) SWIG_fail;
37789 swig_obj[0] = args;
37790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37791 if (!SWIG_IsOK(res1)) {
37792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37793 }
37794 arg1 = reinterpret_cast< wxWindow * >(argp1);
37795 {
37796 PyThreadState* __tstate = wxPyBeginAllowThreads();
37797 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37798 wxPyEndAllowThreads(__tstate);
37799 if (PyErr_Occurred()) SWIG_fail;
37800 }
37801 {
37802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37803 }
37804 return resultobj;
37805 fail:
37806 return NULL;
37807 }
37808
37809
37810 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37811 PyObject *resultobj = 0;
37812 wxWindow *arg1 = (wxWindow *) 0 ;
37813 wxRegion *result = 0 ;
37814 void *argp1 = 0 ;
37815 int res1 = 0 ;
37816 PyObject *swig_obj[1] ;
37817
37818 if (!args) SWIG_fail;
37819 swig_obj[0] = args;
37820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37821 if (!SWIG_IsOK(res1)) {
37822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37823 }
37824 arg1 = reinterpret_cast< wxWindow * >(argp1);
37825 {
37826 PyThreadState* __tstate = wxPyBeginAllowThreads();
37827 {
37828 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37829 result = (wxRegion *) &_result_ref;
37830 }
37831 wxPyEndAllowThreads(__tstate);
37832 if (PyErr_Occurred()) SWIG_fail;
37833 }
37834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37835 return resultobj;
37836 fail:
37837 return NULL;
37838 }
37839
37840
37841 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37842 PyObject *resultobj = 0;
37843 wxWindow *arg1 = (wxWindow *) 0 ;
37844 wxRect result;
37845 void *argp1 = 0 ;
37846 int res1 = 0 ;
37847 PyObject *swig_obj[1] ;
37848
37849 if (!args) SWIG_fail;
37850 swig_obj[0] = args;
37851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37852 if (!SWIG_IsOK(res1)) {
37853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37854 }
37855 arg1 = reinterpret_cast< wxWindow * >(argp1);
37856 {
37857 PyThreadState* __tstate = wxPyBeginAllowThreads();
37858 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37859 wxPyEndAllowThreads(__tstate);
37860 if (PyErr_Occurred()) SWIG_fail;
37861 }
37862 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37863 return resultobj;
37864 fail:
37865 return NULL;
37866 }
37867
37868
37869 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37870 PyObject *resultobj = 0;
37871 wxWindow *arg1 = (wxWindow *) 0 ;
37872 int arg2 ;
37873 int arg3 ;
37874 int arg4 = (int) 1 ;
37875 int arg5 = (int) 1 ;
37876 bool result;
37877 void *argp1 = 0 ;
37878 int res1 = 0 ;
37879 int val2 ;
37880 int ecode2 = 0 ;
37881 int val3 ;
37882 int ecode3 = 0 ;
37883 int val4 ;
37884 int ecode4 = 0 ;
37885 int val5 ;
37886 int ecode5 = 0 ;
37887 PyObject * obj0 = 0 ;
37888 PyObject * obj1 = 0 ;
37889 PyObject * obj2 = 0 ;
37890 PyObject * obj3 = 0 ;
37891 PyObject * obj4 = 0 ;
37892 char * kwnames[] = {
37893 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37894 };
37895
37896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37898 if (!SWIG_IsOK(res1)) {
37899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37900 }
37901 arg1 = reinterpret_cast< wxWindow * >(argp1);
37902 ecode2 = SWIG_AsVal_int(obj1, &val2);
37903 if (!SWIG_IsOK(ecode2)) {
37904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37905 }
37906 arg2 = static_cast< int >(val2);
37907 ecode3 = SWIG_AsVal_int(obj2, &val3);
37908 if (!SWIG_IsOK(ecode3)) {
37909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37910 }
37911 arg3 = static_cast< int >(val3);
37912 if (obj3) {
37913 ecode4 = SWIG_AsVal_int(obj3, &val4);
37914 if (!SWIG_IsOK(ecode4)) {
37915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37916 }
37917 arg4 = static_cast< int >(val4);
37918 }
37919 if (obj4) {
37920 ecode5 = SWIG_AsVal_int(obj4, &val5);
37921 if (!SWIG_IsOK(ecode5)) {
37922 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37923 }
37924 arg5 = static_cast< int >(val5);
37925 }
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 {
37933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37934 }
37935 return resultobj;
37936 fail:
37937 return NULL;
37938 }
37939
37940
37941 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37942 PyObject *resultobj = 0;
37943 wxWindow *arg1 = (wxWindow *) 0 ;
37944 wxPoint *arg2 = 0 ;
37945 bool result;
37946 void *argp1 = 0 ;
37947 int res1 = 0 ;
37948 wxPoint temp2 ;
37949 PyObject * obj0 = 0 ;
37950 PyObject * obj1 = 0 ;
37951 char * kwnames[] = {
37952 (char *) "self",(char *) "pt", NULL
37953 };
37954
37955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
37956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37957 if (!SWIG_IsOK(res1)) {
37958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37959 }
37960 arg1 = reinterpret_cast< wxWindow * >(argp1);
37961 {
37962 arg2 = &temp2;
37963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37964 }
37965 {
37966 PyThreadState* __tstate = wxPyBeginAllowThreads();
37967 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
37968 wxPyEndAllowThreads(__tstate);
37969 if (PyErr_Occurred()) SWIG_fail;
37970 }
37971 {
37972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37973 }
37974 return resultobj;
37975 fail:
37976 return NULL;
37977 }
37978
37979
37980 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37981 PyObject *resultobj = 0;
37982 wxWindow *arg1 = (wxWindow *) 0 ;
37983 wxRect *arg2 = 0 ;
37984 bool result;
37985 void *argp1 = 0 ;
37986 int res1 = 0 ;
37987 wxRect temp2 ;
37988 PyObject * obj0 = 0 ;
37989 PyObject * obj1 = 0 ;
37990 char * kwnames[] = {
37991 (char *) "self",(char *) "rect", NULL
37992 };
37993
37994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
37995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37996 if (!SWIG_IsOK(res1)) {
37997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37998 }
37999 arg1 = reinterpret_cast< wxWindow * >(argp1);
38000 {
38001 arg2 = &temp2;
38002 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38003 }
38004 {
38005 PyThreadState* __tstate = wxPyBeginAllowThreads();
38006 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38007 wxPyEndAllowThreads(__tstate);
38008 if (PyErr_Occurred()) SWIG_fail;
38009 }
38010 {
38011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38012 }
38013 return resultobj;
38014 fail:
38015 return NULL;
38016 }
38017
38018
38019 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38020 PyObject *resultobj = 0;
38021 wxWindow *arg1 = (wxWindow *) 0 ;
38022 SwigValueWrapper<wxVisualAttributes > result;
38023 void *argp1 = 0 ;
38024 int res1 = 0 ;
38025 PyObject *swig_obj[1] ;
38026
38027 if (!args) SWIG_fail;
38028 swig_obj[0] = args;
38029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38030 if (!SWIG_IsOK(res1)) {
38031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38032 }
38033 arg1 = reinterpret_cast< wxWindow * >(argp1);
38034 {
38035 PyThreadState* __tstate = wxPyBeginAllowThreads();
38036 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38037 wxPyEndAllowThreads(__tstate);
38038 if (PyErr_Occurred()) SWIG_fail;
38039 }
38040 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38041 return resultobj;
38042 fail:
38043 return NULL;
38044 }
38045
38046
38047 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38048 PyObject *resultobj = 0;
38049 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38050 SwigValueWrapper<wxVisualAttributes > result;
38051 int val1 ;
38052 int ecode1 = 0 ;
38053 PyObject * obj0 = 0 ;
38054 char * kwnames[] = {
38055 (char *) "variant", NULL
38056 };
38057
38058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38059 if (obj0) {
38060 ecode1 = SWIG_AsVal_int(obj0, &val1);
38061 if (!SWIG_IsOK(ecode1)) {
38062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38063 }
38064 arg1 = static_cast< wxWindowVariant >(val1);
38065 }
38066 {
38067 if (!wxPyCheckForApp()) SWIG_fail;
38068 PyThreadState* __tstate = wxPyBeginAllowThreads();
38069 result = wxWindow::GetClassDefaultAttributes(arg1);
38070 wxPyEndAllowThreads(__tstate);
38071 if (PyErr_Occurred()) SWIG_fail;
38072 }
38073 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38074 return resultobj;
38075 fail:
38076 return NULL;
38077 }
38078
38079
38080 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38081 PyObject *resultobj = 0;
38082 wxWindow *arg1 = (wxWindow *) 0 ;
38083 wxColour *arg2 = 0 ;
38084 bool result;
38085 void *argp1 = 0 ;
38086 int res1 = 0 ;
38087 wxColour temp2 ;
38088 PyObject * obj0 = 0 ;
38089 PyObject * obj1 = 0 ;
38090 char * kwnames[] = {
38091 (char *) "self",(char *) "colour", NULL
38092 };
38093
38094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38096 if (!SWIG_IsOK(res1)) {
38097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38098 }
38099 arg1 = reinterpret_cast< wxWindow * >(argp1);
38100 {
38101 arg2 = &temp2;
38102 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38103 }
38104 {
38105 PyThreadState* __tstate = wxPyBeginAllowThreads();
38106 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38107 wxPyEndAllowThreads(__tstate);
38108 if (PyErr_Occurred()) SWIG_fail;
38109 }
38110 {
38111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38112 }
38113 return resultobj;
38114 fail:
38115 return NULL;
38116 }
38117
38118
38119 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38120 PyObject *resultobj = 0;
38121 wxWindow *arg1 = (wxWindow *) 0 ;
38122 wxColour *arg2 = 0 ;
38123 void *argp1 = 0 ;
38124 int res1 = 0 ;
38125 wxColour temp2 ;
38126 PyObject * obj0 = 0 ;
38127 PyObject * obj1 = 0 ;
38128 char * kwnames[] = {
38129 (char *) "self",(char *) "colour", NULL
38130 };
38131
38132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38134 if (!SWIG_IsOK(res1)) {
38135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38136 }
38137 arg1 = reinterpret_cast< wxWindow * >(argp1);
38138 {
38139 arg2 = &temp2;
38140 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38141 }
38142 {
38143 PyThreadState* __tstate = wxPyBeginAllowThreads();
38144 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38145 wxPyEndAllowThreads(__tstate);
38146 if (PyErr_Occurred()) SWIG_fail;
38147 }
38148 resultobj = SWIG_Py_Void();
38149 return resultobj;
38150 fail:
38151 return NULL;
38152 }
38153
38154
38155 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38156 PyObject *resultobj = 0;
38157 wxWindow *arg1 = (wxWindow *) 0 ;
38158 wxColour *arg2 = 0 ;
38159 bool result;
38160 void *argp1 = 0 ;
38161 int res1 = 0 ;
38162 wxColour temp2 ;
38163 PyObject * obj0 = 0 ;
38164 PyObject * obj1 = 0 ;
38165 char * kwnames[] = {
38166 (char *) "self",(char *) "colour", NULL
38167 };
38168
38169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38171 if (!SWIG_IsOK(res1)) {
38172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38173 }
38174 arg1 = reinterpret_cast< wxWindow * >(argp1);
38175 {
38176 arg2 = &temp2;
38177 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38178 }
38179 {
38180 PyThreadState* __tstate = wxPyBeginAllowThreads();
38181 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38182 wxPyEndAllowThreads(__tstate);
38183 if (PyErr_Occurred()) SWIG_fail;
38184 }
38185 {
38186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38187 }
38188 return resultobj;
38189 fail:
38190 return NULL;
38191 }
38192
38193
38194 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38195 PyObject *resultobj = 0;
38196 wxWindow *arg1 = (wxWindow *) 0 ;
38197 wxColour *arg2 = 0 ;
38198 void *argp1 = 0 ;
38199 int res1 = 0 ;
38200 wxColour temp2 ;
38201 PyObject * obj0 = 0 ;
38202 PyObject * obj1 = 0 ;
38203 char * kwnames[] = {
38204 (char *) "self",(char *) "colour", NULL
38205 };
38206
38207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38209 if (!SWIG_IsOK(res1)) {
38210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38211 }
38212 arg1 = reinterpret_cast< wxWindow * >(argp1);
38213 {
38214 arg2 = &temp2;
38215 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38216 }
38217 {
38218 PyThreadState* __tstate = wxPyBeginAllowThreads();
38219 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38220 wxPyEndAllowThreads(__tstate);
38221 if (PyErr_Occurred()) SWIG_fail;
38222 }
38223 resultobj = SWIG_Py_Void();
38224 return resultobj;
38225 fail:
38226 return NULL;
38227 }
38228
38229
38230 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38231 PyObject *resultobj = 0;
38232 wxWindow *arg1 = (wxWindow *) 0 ;
38233 wxColour result;
38234 void *argp1 = 0 ;
38235 int res1 = 0 ;
38236 PyObject *swig_obj[1] ;
38237
38238 if (!args) SWIG_fail;
38239 swig_obj[0] = args;
38240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38241 if (!SWIG_IsOK(res1)) {
38242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38243 }
38244 arg1 = reinterpret_cast< wxWindow * >(argp1);
38245 {
38246 PyThreadState* __tstate = wxPyBeginAllowThreads();
38247 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38248 wxPyEndAllowThreads(__tstate);
38249 if (PyErr_Occurred()) SWIG_fail;
38250 }
38251 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38252 return resultobj;
38253 fail:
38254 return NULL;
38255 }
38256
38257
38258 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38259 PyObject *resultobj = 0;
38260 wxWindow *arg1 = (wxWindow *) 0 ;
38261 wxColour result;
38262 void *argp1 = 0 ;
38263 int res1 = 0 ;
38264 PyObject *swig_obj[1] ;
38265
38266 if (!args) SWIG_fail;
38267 swig_obj[0] = args;
38268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38269 if (!SWIG_IsOK(res1)) {
38270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38271 }
38272 arg1 = reinterpret_cast< wxWindow * >(argp1);
38273 {
38274 PyThreadState* __tstate = wxPyBeginAllowThreads();
38275 result = ((wxWindow const *)arg1)->GetForegroundColour();
38276 wxPyEndAllowThreads(__tstate);
38277 if (PyErr_Occurred()) SWIG_fail;
38278 }
38279 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38280 return resultobj;
38281 fail:
38282 return NULL;
38283 }
38284
38285
38286 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38287 PyObject *resultobj = 0;
38288 wxWindow *arg1 = (wxWindow *) 0 ;
38289 bool result;
38290 void *argp1 = 0 ;
38291 int res1 = 0 ;
38292 PyObject *swig_obj[1] ;
38293
38294 if (!args) SWIG_fail;
38295 swig_obj[0] = args;
38296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38297 if (!SWIG_IsOK(res1)) {
38298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38299 }
38300 arg1 = reinterpret_cast< wxWindow * >(argp1);
38301 {
38302 PyThreadState* __tstate = wxPyBeginAllowThreads();
38303 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38304 wxPyEndAllowThreads(__tstate);
38305 if (PyErr_Occurred()) SWIG_fail;
38306 }
38307 {
38308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38309 }
38310 return resultobj;
38311 fail:
38312 return NULL;
38313 }
38314
38315
38316 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38317 PyObject *resultobj = 0;
38318 wxWindow *arg1 = (wxWindow *) 0 ;
38319 bool result;
38320 void *argp1 = 0 ;
38321 int res1 = 0 ;
38322 PyObject *swig_obj[1] ;
38323
38324 if (!args) SWIG_fail;
38325 swig_obj[0] = args;
38326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38327 if (!SWIG_IsOK(res1)) {
38328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38329 }
38330 arg1 = reinterpret_cast< wxWindow * >(argp1);
38331 {
38332 PyThreadState* __tstate = wxPyBeginAllowThreads();
38333 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38334 wxPyEndAllowThreads(__tstate);
38335 if (PyErr_Occurred()) SWIG_fail;
38336 }
38337 {
38338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38339 }
38340 return resultobj;
38341 fail:
38342 return NULL;
38343 }
38344
38345
38346 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38347 PyObject *resultobj = 0;
38348 wxWindow *arg1 = (wxWindow *) 0 ;
38349 wxBackgroundStyle arg2 ;
38350 bool result;
38351 void *argp1 = 0 ;
38352 int res1 = 0 ;
38353 int val2 ;
38354 int ecode2 = 0 ;
38355 PyObject * obj0 = 0 ;
38356 PyObject * obj1 = 0 ;
38357 char * kwnames[] = {
38358 (char *) "self",(char *) "style", NULL
38359 };
38360
38361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38363 if (!SWIG_IsOK(res1)) {
38364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38365 }
38366 arg1 = reinterpret_cast< wxWindow * >(argp1);
38367 ecode2 = SWIG_AsVal_int(obj1, &val2);
38368 if (!SWIG_IsOK(ecode2)) {
38369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38370 }
38371 arg2 = static_cast< wxBackgroundStyle >(val2);
38372 {
38373 PyThreadState* __tstate = wxPyBeginAllowThreads();
38374 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38375 wxPyEndAllowThreads(__tstate);
38376 if (PyErr_Occurred()) SWIG_fail;
38377 }
38378 {
38379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38380 }
38381 return resultobj;
38382 fail:
38383 return NULL;
38384 }
38385
38386
38387 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38388 PyObject *resultobj = 0;
38389 wxWindow *arg1 = (wxWindow *) 0 ;
38390 wxBackgroundStyle result;
38391 void *argp1 = 0 ;
38392 int res1 = 0 ;
38393 PyObject *swig_obj[1] ;
38394
38395 if (!args) SWIG_fail;
38396 swig_obj[0] = args;
38397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38398 if (!SWIG_IsOK(res1)) {
38399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38400 }
38401 arg1 = reinterpret_cast< wxWindow * >(argp1);
38402 {
38403 PyThreadState* __tstate = wxPyBeginAllowThreads();
38404 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38405 wxPyEndAllowThreads(__tstate);
38406 if (PyErr_Occurred()) SWIG_fail;
38407 }
38408 resultobj = SWIG_From_int(static_cast< int >(result));
38409 return resultobj;
38410 fail:
38411 return NULL;
38412 }
38413
38414
38415 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38416 PyObject *resultobj = 0;
38417 wxWindow *arg1 = (wxWindow *) 0 ;
38418 bool result;
38419 void *argp1 = 0 ;
38420 int res1 = 0 ;
38421 PyObject *swig_obj[1] ;
38422
38423 if (!args) SWIG_fail;
38424 swig_obj[0] = args;
38425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38426 if (!SWIG_IsOK(res1)) {
38427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38428 }
38429 arg1 = reinterpret_cast< wxWindow * >(argp1);
38430 {
38431 PyThreadState* __tstate = wxPyBeginAllowThreads();
38432 result = (bool)(arg1)->HasTransparentBackground();
38433 wxPyEndAllowThreads(__tstate);
38434 if (PyErr_Occurred()) SWIG_fail;
38435 }
38436 {
38437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38438 }
38439 return resultobj;
38440 fail:
38441 return NULL;
38442 }
38443
38444
38445 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38446 PyObject *resultobj = 0;
38447 wxWindow *arg1 = (wxWindow *) 0 ;
38448 wxCursor *arg2 = 0 ;
38449 bool result;
38450 void *argp1 = 0 ;
38451 int res1 = 0 ;
38452 void *argp2 = 0 ;
38453 int res2 = 0 ;
38454 PyObject * obj0 = 0 ;
38455 PyObject * obj1 = 0 ;
38456 char * kwnames[] = {
38457 (char *) "self",(char *) "cursor", NULL
38458 };
38459
38460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38462 if (!SWIG_IsOK(res1)) {
38463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38464 }
38465 arg1 = reinterpret_cast< wxWindow * >(argp1);
38466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38467 if (!SWIG_IsOK(res2)) {
38468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38469 }
38470 if (!argp2) {
38471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38472 }
38473 arg2 = reinterpret_cast< wxCursor * >(argp2);
38474 {
38475 PyThreadState* __tstate = wxPyBeginAllowThreads();
38476 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38477 wxPyEndAllowThreads(__tstate);
38478 if (PyErr_Occurred()) SWIG_fail;
38479 }
38480 {
38481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38482 }
38483 return resultobj;
38484 fail:
38485 return NULL;
38486 }
38487
38488
38489 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38490 PyObject *resultobj = 0;
38491 wxWindow *arg1 = (wxWindow *) 0 ;
38492 wxCursor result;
38493 void *argp1 = 0 ;
38494 int res1 = 0 ;
38495 PyObject *swig_obj[1] ;
38496
38497 if (!args) SWIG_fail;
38498 swig_obj[0] = args;
38499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38500 if (!SWIG_IsOK(res1)) {
38501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38502 }
38503 arg1 = reinterpret_cast< wxWindow * >(argp1);
38504 {
38505 PyThreadState* __tstate = wxPyBeginAllowThreads();
38506 result = (arg1)->GetCursor();
38507 wxPyEndAllowThreads(__tstate);
38508 if (PyErr_Occurred()) SWIG_fail;
38509 }
38510 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38511 return resultobj;
38512 fail:
38513 return NULL;
38514 }
38515
38516
38517 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38518 PyObject *resultobj = 0;
38519 wxWindow *arg1 = (wxWindow *) 0 ;
38520 wxFont *arg2 = 0 ;
38521 bool result;
38522 void *argp1 = 0 ;
38523 int res1 = 0 ;
38524 void *argp2 = 0 ;
38525 int res2 = 0 ;
38526 PyObject * obj0 = 0 ;
38527 PyObject * obj1 = 0 ;
38528 char * kwnames[] = {
38529 (char *) "self",(char *) "font", NULL
38530 };
38531
38532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38534 if (!SWIG_IsOK(res1)) {
38535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38536 }
38537 arg1 = reinterpret_cast< wxWindow * >(argp1);
38538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38539 if (!SWIG_IsOK(res2)) {
38540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38541 }
38542 if (!argp2) {
38543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38544 }
38545 arg2 = reinterpret_cast< wxFont * >(argp2);
38546 {
38547 PyThreadState* __tstate = wxPyBeginAllowThreads();
38548 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38549 wxPyEndAllowThreads(__tstate);
38550 if (PyErr_Occurred()) SWIG_fail;
38551 }
38552 {
38553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38554 }
38555 return resultobj;
38556 fail:
38557 return NULL;
38558 }
38559
38560
38561 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38562 PyObject *resultobj = 0;
38563 wxWindow *arg1 = (wxWindow *) 0 ;
38564 wxFont *arg2 = 0 ;
38565 void *argp1 = 0 ;
38566 int res1 = 0 ;
38567 void *argp2 = 0 ;
38568 int res2 = 0 ;
38569 PyObject * obj0 = 0 ;
38570 PyObject * obj1 = 0 ;
38571 char * kwnames[] = {
38572 (char *) "self",(char *) "font", NULL
38573 };
38574
38575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38577 if (!SWIG_IsOK(res1)) {
38578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38579 }
38580 arg1 = reinterpret_cast< wxWindow * >(argp1);
38581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38582 if (!SWIG_IsOK(res2)) {
38583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38584 }
38585 if (!argp2) {
38586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38587 }
38588 arg2 = reinterpret_cast< wxFont * >(argp2);
38589 {
38590 PyThreadState* __tstate = wxPyBeginAllowThreads();
38591 (arg1)->SetOwnFont((wxFont const &)*arg2);
38592 wxPyEndAllowThreads(__tstate);
38593 if (PyErr_Occurred()) SWIG_fail;
38594 }
38595 resultobj = SWIG_Py_Void();
38596 return resultobj;
38597 fail:
38598 return NULL;
38599 }
38600
38601
38602 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38603 PyObject *resultobj = 0;
38604 wxWindow *arg1 = (wxWindow *) 0 ;
38605 wxFont result;
38606 void *argp1 = 0 ;
38607 int res1 = 0 ;
38608 PyObject *swig_obj[1] ;
38609
38610 if (!args) SWIG_fail;
38611 swig_obj[0] = args;
38612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38613 if (!SWIG_IsOK(res1)) {
38614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38615 }
38616 arg1 = reinterpret_cast< wxWindow * >(argp1);
38617 {
38618 PyThreadState* __tstate = wxPyBeginAllowThreads();
38619 result = (arg1)->GetFont();
38620 wxPyEndAllowThreads(__tstate);
38621 if (PyErr_Occurred()) SWIG_fail;
38622 }
38623 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38624 return resultobj;
38625 fail:
38626 return NULL;
38627 }
38628
38629
38630 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38631 PyObject *resultobj = 0;
38632 wxWindow *arg1 = (wxWindow *) 0 ;
38633 wxCaret *arg2 = (wxCaret *) 0 ;
38634 void *argp1 = 0 ;
38635 int res1 = 0 ;
38636 int res2 = 0 ;
38637 PyObject * obj0 = 0 ;
38638 PyObject * obj1 = 0 ;
38639 char * kwnames[] = {
38640 (char *) "self",(char *) "caret", NULL
38641 };
38642
38643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38645 if (!SWIG_IsOK(res1)) {
38646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38647 }
38648 arg1 = reinterpret_cast< wxWindow * >(argp1);
38649 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38650 if (!SWIG_IsOK(res2)) {
38651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38652 }
38653 {
38654 PyThreadState* __tstate = wxPyBeginAllowThreads();
38655 (arg1)->SetCaret(arg2);
38656 wxPyEndAllowThreads(__tstate);
38657 if (PyErr_Occurred()) SWIG_fail;
38658 }
38659 resultobj = SWIG_Py_Void();
38660 return resultobj;
38661 fail:
38662 return NULL;
38663 }
38664
38665
38666 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38667 PyObject *resultobj = 0;
38668 wxWindow *arg1 = (wxWindow *) 0 ;
38669 wxCaret *result = 0 ;
38670 void *argp1 = 0 ;
38671 int res1 = 0 ;
38672 PyObject *swig_obj[1] ;
38673
38674 if (!args) SWIG_fail;
38675 swig_obj[0] = args;
38676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38677 if (!SWIG_IsOK(res1)) {
38678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38679 }
38680 arg1 = reinterpret_cast< wxWindow * >(argp1);
38681 {
38682 PyThreadState* __tstate = wxPyBeginAllowThreads();
38683 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38684 wxPyEndAllowThreads(__tstate);
38685 if (PyErr_Occurred()) SWIG_fail;
38686 }
38687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38688 return resultobj;
38689 fail:
38690 return NULL;
38691 }
38692
38693
38694 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38695 PyObject *resultobj = 0;
38696 wxWindow *arg1 = (wxWindow *) 0 ;
38697 int result;
38698 void *argp1 = 0 ;
38699 int res1 = 0 ;
38700 PyObject *swig_obj[1] ;
38701
38702 if (!args) SWIG_fail;
38703 swig_obj[0] = args;
38704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38705 if (!SWIG_IsOK(res1)) {
38706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38707 }
38708 arg1 = reinterpret_cast< wxWindow * >(argp1);
38709 {
38710 PyThreadState* __tstate = wxPyBeginAllowThreads();
38711 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38712 wxPyEndAllowThreads(__tstate);
38713 if (PyErr_Occurred()) SWIG_fail;
38714 }
38715 resultobj = SWIG_From_int(static_cast< int >(result));
38716 return resultobj;
38717 fail:
38718 return NULL;
38719 }
38720
38721
38722 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38723 PyObject *resultobj = 0;
38724 wxWindow *arg1 = (wxWindow *) 0 ;
38725 int result;
38726 void *argp1 = 0 ;
38727 int res1 = 0 ;
38728 PyObject *swig_obj[1] ;
38729
38730 if (!args) SWIG_fail;
38731 swig_obj[0] = args;
38732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38733 if (!SWIG_IsOK(res1)) {
38734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38735 }
38736 arg1 = reinterpret_cast< wxWindow * >(argp1);
38737 {
38738 PyThreadState* __tstate = wxPyBeginAllowThreads();
38739 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38740 wxPyEndAllowThreads(__tstate);
38741 if (PyErr_Occurred()) SWIG_fail;
38742 }
38743 resultobj = SWIG_From_int(static_cast< int >(result));
38744 return resultobj;
38745 fail:
38746 return NULL;
38747 }
38748
38749
38750 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38751 PyObject *resultobj = 0;
38752 wxWindow *arg1 = (wxWindow *) 0 ;
38753 wxString *arg2 = 0 ;
38754 int *arg3 = (int *) 0 ;
38755 int *arg4 = (int *) 0 ;
38756 void *argp1 = 0 ;
38757 int res1 = 0 ;
38758 bool temp2 = false ;
38759 int temp3 ;
38760 int res3 = SWIG_TMPOBJ ;
38761 int temp4 ;
38762 int res4 = SWIG_TMPOBJ ;
38763 PyObject * obj0 = 0 ;
38764 PyObject * obj1 = 0 ;
38765 char * kwnames[] = {
38766 (char *) "self",(char *) "string", NULL
38767 };
38768
38769 arg3 = &temp3;
38770 arg4 = &temp4;
38771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38773 if (!SWIG_IsOK(res1)) {
38774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38775 }
38776 arg1 = reinterpret_cast< wxWindow * >(argp1);
38777 {
38778 arg2 = wxString_in_helper(obj1);
38779 if (arg2 == NULL) SWIG_fail;
38780 temp2 = true;
38781 }
38782 {
38783 PyThreadState* __tstate = wxPyBeginAllowThreads();
38784 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38785 wxPyEndAllowThreads(__tstate);
38786 if (PyErr_Occurred()) SWIG_fail;
38787 }
38788 resultobj = SWIG_Py_Void();
38789 if (SWIG_IsTmpObj(res3)) {
38790 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38791 } else {
38792 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38793 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38794 }
38795 if (SWIG_IsTmpObj(res4)) {
38796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38797 } else {
38798 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38800 }
38801 {
38802 if (temp2)
38803 delete arg2;
38804 }
38805 return resultobj;
38806 fail:
38807 {
38808 if (temp2)
38809 delete arg2;
38810 }
38811 return NULL;
38812 }
38813
38814
38815 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38816 PyObject *resultobj = 0;
38817 wxWindow *arg1 = (wxWindow *) 0 ;
38818 wxString *arg2 = 0 ;
38819 int *arg3 = (int *) 0 ;
38820 int *arg4 = (int *) 0 ;
38821 int *arg5 = (int *) 0 ;
38822 int *arg6 = (int *) 0 ;
38823 wxFont *arg7 = (wxFont *) NULL ;
38824 void *argp1 = 0 ;
38825 int res1 = 0 ;
38826 bool temp2 = false ;
38827 int temp3 ;
38828 int res3 = SWIG_TMPOBJ ;
38829 int temp4 ;
38830 int res4 = SWIG_TMPOBJ ;
38831 int temp5 ;
38832 int res5 = SWIG_TMPOBJ ;
38833 int temp6 ;
38834 int res6 = SWIG_TMPOBJ ;
38835 void *argp7 = 0 ;
38836 int res7 = 0 ;
38837 PyObject * obj0 = 0 ;
38838 PyObject * obj1 = 0 ;
38839 PyObject * obj2 = 0 ;
38840 char * kwnames[] = {
38841 (char *) "self",(char *) "string",(char *) "font", NULL
38842 };
38843
38844 arg3 = &temp3;
38845 arg4 = &temp4;
38846 arg5 = &temp5;
38847 arg6 = &temp6;
38848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38850 if (!SWIG_IsOK(res1)) {
38851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38852 }
38853 arg1 = reinterpret_cast< wxWindow * >(argp1);
38854 {
38855 arg2 = wxString_in_helper(obj1);
38856 if (arg2 == NULL) SWIG_fail;
38857 temp2 = true;
38858 }
38859 if (obj2) {
38860 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38861 if (!SWIG_IsOK(res7)) {
38862 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38863 }
38864 arg7 = reinterpret_cast< wxFont * >(argp7);
38865 }
38866 {
38867 PyThreadState* __tstate = wxPyBeginAllowThreads();
38868 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38869 wxPyEndAllowThreads(__tstate);
38870 if (PyErr_Occurred()) SWIG_fail;
38871 }
38872 resultobj = SWIG_Py_Void();
38873 if (SWIG_IsTmpObj(res3)) {
38874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38875 } else {
38876 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38878 }
38879 if (SWIG_IsTmpObj(res4)) {
38880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38881 } else {
38882 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38884 }
38885 if (SWIG_IsTmpObj(res5)) {
38886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38887 } else {
38888 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38890 }
38891 if (SWIG_IsTmpObj(res6)) {
38892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38893 } else {
38894 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38896 }
38897 {
38898 if (temp2)
38899 delete arg2;
38900 }
38901 return resultobj;
38902 fail:
38903 {
38904 if (temp2)
38905 delete arg2;
38906 }
38907 return NULL;
38908 }
38909
38910
38911 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38912 PyObject *resultobj = 0;
38913 wxWindow *arg1 = (wxWindow *) 0 ;
38914 int *arg2 = (int *) 0 ;
38915 int *arg3 = (int *) 0 ;
38916 void *argp1 = 0 ;
38917 int res1 = 0 ;
38918 int temp2 ;
38919 int res2 = 0 ;
38920 int temp3 ;
38921 int res3 = 0 ;
38922 PyObject * obj0 = 0 ;
38923 PyObject * obj1 = 0 ;
38924 PyObject * obj2 = 0 ;
38925 char * kwnames[] = {
38926 (char *) "self",(char *) "x",(char *) "y", NULL
38927 };
38928
38929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38931 if (!SWIG_IsOK(res1)) {
38932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38933 }
38934 arg1 = reinterpret_cast< wxWindow * >(argp1);
38935 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
38936 int val;
38937 int ecode = SWIG_AsVal_int(obj1, &val);
38938 if (!SWIG_IsOK(ecode)) {
38939 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
38940 }
38941 temp2 = static_cast< int >(val);
38942 arg2 = &temp2;
38943 res2 = SWIG_AddTmpMask(ecode);
38944 }
38945 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
38946 int val;
38947 int ecode = SWIG_AsVal_int(obj2, &val);
38948 if (!SWIG_IsOK(ecode)) {
38949 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
38950 }
38951 temp3 = static_cast< int >(val);
38952 arg3 = &temp3;
38953 res3 = SWIG_AddTmpMask(ecode);
38954 }
38955 {
38956 PyThreadState* __tstate = wxPyBeginAllowThreads();
38957 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
38958 wxPyEndAllowThreads(__tstate);
38959 if (PyErr_Occurred()) SWIG_fail;
38960 }
38961 resultobj = SWIG_Py_Void();
38962 if (SWIG_IsTmpObj(res2)) {
38963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
38964 } else {
38965 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
38967 }
38968 if (SWIG_IsTmpObj(res3)) {
38969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38970 } else {
38971 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38973 }
38974 return resultobj;
38975 fail:
38976 return NULL;
38977 }
38978
38979
38980 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38981 PyObject *resultobj = 0;
38982 wxWindow *arg1 = (wxWindow *) 0 ;
38983 int *arg2 = (int *) 0 ;
38984 int *arg3 = (int *) 0 ;
38985 void *argp1 = 0 ;
38986 int res1 = 0 ;
38987 int temp2 ;
38988 int res2 = 0 ;
38989 int temp3 ;
38990 int res3 = 0 ;
38991 PyObject * obj0 = 0 ;
38992 PyObject * obj1 = 0 ;
38993 PyObject * obj2 = 0 ;
38994 char * kwnames[] = {
38995 (char *) "self",(char *) "x",(char *) "y", NULL
38996 };
38997
38998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39000 if (!SWIG_IsOK(res1)) {
39001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39002 }
39003 arg1 = reinterpret_cast< wxWindow * >(argp1);
39004 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39005 int val;
39006 int ecode = SWIG_AsVal_int(obj1, &val);
39007 if (!SWIG_IsOK(ecode)) {
39008 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39009 }
39010 temp2 = static_cast< int >(val);
39011 arg2 = &temp2;
39012 res2 = SWIG_AddTmpMask(ecode);
39013 }
39014 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39015 int val;
39016 int ecode = SWIG_AsVal_int(obj2, &val);
39017 if (!SWIG_IsOK(ecode)) {
39018 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39019 }
39020 temp3 = static_cast< int >(val);
39021 arg3 = &temp3;
39022 res3 = SWIG_AddTmpMask(ecode);
39023 }
39024 {
39025 PyThreadState* __tstate = wxPyBeginAllowThreads();
39026 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39027 wxPyEndAllowThreads(__tstate);
39028 if (PyErr_Occurred()) SWIG_fail;
39029 }
39030 resultobj = SWIG_Py_Void();
39031 if (SWIG_IsTmpObj(res2)) {
39032 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39033 } else {
39034 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39035 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39036 }
39037 if (SWIG_IsTmpObj(res3)) {
39038 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39039 } else {
39040 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39041 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39042 }
39043 return resultobj;
39044 fail:
39045 return NULL;
39046 }
39047
39048
39049 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39050 PyObject *resultobj = 0;
39051 wxWindow *arg1 = (wxWindow *) 0 ;
39052 wxPoint *arg2 = 0 ;
39053 wxPoint result;
39054 void *argp1 = 0 ;
39055 int res1 = 0 ;
39056 wxPoint temp2 ;
39057 PyObject * obj0 = 0 ;
39058 PyObject * obj1 = 0 ;
39059 char * kwnames[] = {
39060 (char *) "self",(char *) "pt", NULL
39061 };
39062
39063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39065 if (!SWIG_IsOK(res1)) {
39066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39067 }
39068 arg1 = reinterpret_cast< wxWindow * >(argp1);
39069 {
39070 arg2 = &temp2;
39071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39072 }
39073 {
39074 PyThreadState* __tstate = wxPyBeginAllowThreads();
39075 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39076 wxPyEndAllowThreads(__tstate);
39077 if (PyErr_Occurred()) SWIG_fail;
39078 }
39079 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39080 return resultobj;
39081 fail:
39082 return NULL;
39083 }
39084
39085
39086 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39087 PyObject *resultobj = 0;
39088 wxWindow *arg1 = (wxWindow *) 0 ;
39089 wxPoint *arg2 = 0 ;
39090 wxPoint result;
39091 void *argp1 = 0 ;
39092 int res1 = 0 ;
39093 wxPoint temp2 ;
39094 PyObject * obj0 = 0 ;
39095 PyObject * obj1 = 0 ;
39096 char * kwnames[] = {
39097 (char *) "self",(char *) "pt", NULL
39098 };
39099
39100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39102 if (!SWIG_IsOK(res1)) {
39103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39104 }
39105 arg1 = reinterpret_cast< wxWindow * >(argp1);
39106 {
39107 arg2 = &temp2;
39108 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39109 }
39110 {
39111 PyThreadState* __tstate = wxPyBeginAllowThreads();
39112 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39113 wxPyEndAllowThreads(__tstate);
39114 if (PyErr_Occurred()) SWIG_fail;
39115 }
39116 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39117 return resultobj;
39118 fail:
39119 return NULL;
39120 }
39121
39122
39123 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39124 PyObject *resultobj = 0;
39125 wxWindow *arg1 = (wxWindow *) 0 ;
39126 int arg2 ;
39127 int arg3 ;
39128 wxHitTest result;
39129 void *argp1 = 0 ;
39130 int res1 = 0 ;
39131 int val2 ;
39132 int ecode2 = 0 ;
39133 int val3 ;
39134 int ecode3 = 0 ;
39135 PyObject * obj0 = 0 ;
39136 PyObject * obj1 = 0 ;
39137 PyObject * obj2 = 0 ;
39138 char * kwnames[] = {
39139 (char *) "self",(char *) "x",(char *) "y", NULL
39140 };
39141
39142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39144 if (!SWIG_IsOK(res1)) {
39145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39146 }
39147 arg1 = reinterpret_cast< wxWindow * >(argp1);
39148 ecode2 = SWIG_AsVal_int(obj1, &val2);
39149 if (!SWIG_IsOK(ecode2)) {
39150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39151 }
39152 arg2 = static_cast< int >(val2);
39153 ecode3 = SWIG_AsVal_int(obj2, &val3);
39154 if (!SWIG_IsOK(ecode3)) {
39155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39156 }
39157 arg3 = static_cast< int >(val3);
39158 {
39159 PyThreadState* __tstate = wxPyBeginAllowThreads();
39160 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39161 wxPyEndAllowThreads(__tstate);
39162 if (PyErr_Occurred()) SWIG_fail;
39163 }
39164 resultobj = SWIG_From_int(static_cast< int >(result));
39165 return resultobj;
39166 fail:
39167 return NULL;
39168 }
39169
39170
39171 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39172 PyObject *resultobj = 0;
39173 wxWindow *arg1 = (wxWindow *) 0 ;
39174 wxPoint *arg2 = 0 ;
39175 wxHitTest result;
39176 void *argp1 = 0 ;
39177 int res1 = 0 ;
39178 wxPoint temp2 ;
39179 PyObject * obj0 = 0 ;
39180 PyObject * obj1 = 0 ;
39181 char * kwnames[] = {
39182 (char *) "self",(char *) "pt", NULL
39183 };
39184
39185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39187 if (!SWIG_IsOK(res1)) {
39188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39189 }
39190 arg1 = reinterpret_cast< wxWindow * >(argp1);
39191 {
39192 arg2 = &temp2;
39193 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39194 }
39195 {
39196 PyThreadState* __tstate = wxPyBeginAllowThreads();
39197 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39198 wxPyEndAllowThreads(__tstate);
39199 if (PyErr_Occurred()) SWIG_fail;
39200 }
39201 resultobj = SWIG_From_int(static_cast< int >(result));
39202 return resultobj;
39203 fail:
39204 return NULL;
39205 }
39206
39207
39208 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39209 PyObject *resultobj = 0;
39210 wxWindow *arg1 = (wxWindow *) 0 ;
39211 long arg2 ;
39212 wxBorder result;
39213 void *argp1 = 0 ;
39214 int res1 = 0 ;
39215 long val2 ;
39216 int ecode2 = 0 ;
39217
39218 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39220 if (!SWIG_IsOK(res1)) {
39221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39222 }
39223 arg1 = reinterpret_cast< wxWindow * >(argp1);
39224 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39225 if (!SWIG_IsOK(ecode2)) {
39226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39227 }
39228 arg2 = static_cast< long >(val2);
39229 {
39230 PyThreadState* __tstate = wxPyBeginAllowThreads();
39231 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39232 wxPyEndAllowThreads(__tstate);
39233 if (PyErr_Occurred()) SWIG_fail;
39234 }
39235 resultobj = SWIG_From_int(static_cast< int >(result));
39236 return resultobj;
39237 fail:
39238 return NULL;
39239 }
39240
39241
39242 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39243 PyObject *resultobj = 0;
39244 wxWindow *arg1 = (wxWindow *) 0 ;
39245 wxBorder result;
39246 void *argp1 = 0 ;
39247 int res1 = 0 ;
39248
39249 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39251 if (!SWIG_IsOK(res1)) {
39252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39253 }
39254 arg1 = reinterpret_cast< wxWindow * >(argp1);
39255 {
39256 PyThreadState* __tstate = wxPyBeginAllowThreads();
39257 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39258 wxPyEndAllowThreads(__tstate);
39259 if (PyErr_Occurred()) SWIG_fail;
39260 }
39261 resultobj = SWIG_From_int(static_cast< int >(result));
39262 return resultobj;
39263 fail:
39264 return NULL;
39265 }
39266
39267
39268 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39269 int argc;
39270 PyObject *argv[3];
39271
39272 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39273 --argc;
39274 if (argc == 1) {
39275 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39276 }
39277 if (argc == 2) {
39278 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39279 }
39280
39281 fail:
39282 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39283 return NULL;
39284 }
39285
39286
39287 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39288 PyObject *resultobj = 0;
39289 wxWindow *arg1 = (wxWindow *) 0 ;
39290 long arg2 = (long) wxUPDATE_UI_NONE ;
39291 void *argp1 = 0 ;
39292 int res1 = 0 ;
39293 long val2 ;
39294 int ecode2 = 0 ;
39295 PyObject * obj0 = 0 ;
39296 PyObject * obj1 = 0 ;
39297 char * kwnames[] = {
39298 (char *) "self",(char *) "flags", NULL
39299 };
39300
39301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39303 if (!SWIG_IsOK(res1)) {
39304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39305 }
39306 arg1 = reinterpret_cast< wxWindow * >(argp1);
39307 if (obj1) {
39308 ecode2 = SWIG_AsVal_long(obj1, &val2);
39309 if (!SWIG_IsOK(ecode2)) {
39310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39311 }
39312 arg2 = static_cast< long >(val2);
39313 }
39314 {
39315 PyThreadState* __tstate = wxPyBeginAllowThreads();
39316 (arg1)->UpdateWindowUI(arg2);
39317 wxPyEndAllowThreads(__tstate);
39318 if (PyErr_Occurred()) SWIG_fail;
39319 }
39320 resultobj = SWIG_Py_Void();
39321 return resultobj;
39322 fail:
39323 return NULL;
39324 }
39325
39326
39327 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39328 PyObject *resultobj = 0;
39329 wxWindow *arg1 = (wxWindow *) 0 ;
39330 wxMenu *arg2 = (wxMenu *) 0 ;
39331 int arg3 = (int) -1 ;
39332 int arg4 = (int) -1 ;
39333 bool result;
39334 void *argp1 = 0 ;
39335 int res1 = 0 ;
39336 void *argp2 = 0 ;
39337 int res2 = 0 ;
39338 int val3 ;
39339 int ecode3 = 0 ;
39340 int val4 ;
39341 int ecode4 = 0 ;
39342 PyObject * obj0 = 0 ;
39343 PyObject * obj1 = 0 ;
39344 PyObject * obj2 = 0 ;
39345 PyObject * obj3 = 0 ;
39346 char * kwnames[] = {
39347 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39348 };
39349
39350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39352 if (!SWIG_IsOK(res1)) {
39353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39354 }
39355 arg1 = reinterpret_cast< wxWindow * >(argp1);
39356 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39357 if (!SWIG_IsOK(res2)) {
39358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39359 }
39360 arg2 = reinterpret_cast< wxMenu * >(argp2);
39361 if (obj2) {
39362 ecode3 = SWIG_AsVal_int(obj2, &val3);
39363 if (!SWIG_IsOK(ecode3)) {
39364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39365 }
39366 arg3 = static_cast< int >(val3);
39367 }
39368 if (obj3) {
39369 ecode4 = SWIG_AsVal_int(obj3, &val4);
39370 if (!SWIG_IsOK(ecode4)) {
39371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39372 }
39373 arg4 = static_cast< int >(val4);
39374 }
39375 {
39376 PyThreadState* __tstate = wxPyBeginAllowThreads();
39377 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39378 wxPyEndAllowThreads(__tstate);
39379 if (PyErr_Occurred()) SWIG_fail;
39380 }
39381 {
39382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39383 }
39384 return resultobj;
39385 fail:
39386 return NULL;
39387 }
39388
39389
39390 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39391 PyObject *resultobj = 0;
39392 wxWindow *arg1 = (wxWindow *) 0 ;
39393 wxMenu *arg2 = (wxMenu *) 0 ;
39394 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39395 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39396 bool result;
39397 void *argp1 = 0 ;
39398 int res1 = 0 ;
39399 void *argp2 = 0 ;
39400 int res2 = 0 ;
39401 wxPoint temp3 ;
39402 PyObject * obj0 = 0 ;
39403 PyObject * obj1 = 0 ;
39404 PyObject * obj2 = 0 ;
39405 char * kwnames[] = {
39406 (char *) "self",(char *) "menu",(char *) "pos", NULL
39407 };
39408
39409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39411 if (!SWIG_IsOK(res1)) {
39412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39413 }
39414 arg1 = reinterpret_cast< wxWindow * >(argp1);
39415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39416 if (!SWIG_IsOK(res2)) {
39417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39418 }
39419 arg2 = reinterpret_cast< wxMenu * >(argp2);
39420 if (obj2) {
39421 {
39422 arg3 = &temp3;
39423 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39424 }
39425 }
39426 {
39427 PyThreadState* __tstate = wxPyBeginAllowThreads();
39428 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39429 wxPyEndAllowThreads(__tstate);
39430 if (PyErr_Occurred()) SWIG_fail;
39431 }
39432 {
39433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39434 }
39435 return resultobj;
39436 fail:
39437 return NULL;
39438 }
39439
39440
39441 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39442 PyObject *resultobj = 0;
39443 wxWindow *arg1 = (wxWindow *) 0 ;
39444 bool result;
39445 void *argp1 = 0 ;
39446 int res1 = 0 ;
39447 PyObject *swig_obj[1] ;
39448
39449 if (!args) SWIG_fail;
39450 swig_obj[0] = args;
39451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39452 if (!SWIG_IsOK(res1)) {
39453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39454 }
39455 arg1 = reinterpret_cast< wxWindow * >(argp1);
39456 {
39457 PyThreadState* __tstate = wxPyBeginAllowThreads();
39458 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39459 wxPyEndAllowThreads(__tstate);
39460 if (PyErr_Occurred()) SWIG_fail;
39461 }
39462 {
39463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39464 }
39465 return resultobj;
39466 fail:
39467 return NULL;
39468 }
39469
39470
39471 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39472 PyObject *resultobj = 0;
39473 wxWindow *arg1 = (wxWindow *) 0 ;
39474 long result;
39475 void *argp1 = 0 ;
39476 int res1 = 0 ;
39477 PyObject *swig_obj[1] ;
39478
39479 if (!args) SWIG_fail;
39480 swig_obj[0] = args;
39481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39482 if (!SWIG_IsOK(res1)) {
39483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39484 }
39485 arg1 = reinterpret_cast< wxWindow * >(argp1);
39486 {
39487 PyThreadState* __tstate = wxPyBeginAllowThreads();
39488 result = (long)wxWindow_GetHandle(arg1);
39489 wxPyEndAllowThreads(__tstate);
39490 if (PyErr_Occurred()) SWIG_fail;
39491 }
39492 resultobj = SWIG_From_long(static_cast< long >(result));
39493 return resultobj;
39494 fail:
39495 return NULL;
39496 }
39497
39498
39499 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39500 PyObject *resultobj = 0;
39501 wxWindow *arg1 = (wxWindow *) 0 ;
39502 long arg2 ;
39503 void *argp1 = 0 ;
39504 int res1 = 0 ;
39505 long val2 ;
39506 int ecode2 = 0 ;
39507 PyObject * obj0 = 0 ;
39508 PyObject * obj1 = 0 ;
39509 char * kwnames[] = {
39510 (char *) "self",(char *) "handle", NULL
39511 };
39512
39513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39515 if (!SWIG_IsOK(res1)) {
39516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39517 }
39518 arg1 = reinterpret_cast< wxWindow * >(argp1);
39519 ecode2 = SWIG_AsVal_long(obj1, &val2);
39520 if (!SWIG_IsOK(ecode2)) {
39521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39522 }
39523 arg2 = static_cast< long >(val2);
39524 {
39525 PyThreadState* __tstate = wxPyBeginAllowThreads();
39526 wxWindow_AssociateHandle(arg1,arg2);
39527 wxPyEndAllowThreads(__tstate);
39528 if (PyErr_Occurred()) SWIG_fail;
39529 }
39530 resultobj = SWIG_Py_Void();
39531 return resultobj;
39532 fail:
39533 return NULL;
39534 }
39535
39536
39537 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39538 PyObject *resultobj = 0;
39539 wxWindow *arg1 = (wxWindow *) 0 ;
39540 void *argp1 = 0 ;
39541 int res1 = 0 ;
39542 PyObject *swig_obj[1] ;
39543
39544 if (!args) SWIG_fail;
39545 swig_obj[0] = args;
39546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39547 if (!SWIG_IsOK(res1)) {
39548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39549 }
39550 arg1 = reinterpret_cast< wxWindow * >(argp1);
39551 {
39552 PyThreadState* __tstate = wxPyBeginAllowThreads();
39553 (arg1)->DissociateHandle();
39554 wxPyEndAllowThreads(__tstate);
39555 if (PyErr_Occurred()) SWIG_fail;
39556 }
39557 resultobj = SWIG_Py_Void();
39558 return resultobj;
39559 fail:
39560 return NULL;
39561 }
39562
39563
39564 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39565 PyObject *resultobj = 0;
39566 wxWindow *arg1 = (wxWindow *) 0 ;
39567 wxPaintEvent *arg2 = 0 ;
39568 void *argp1 = 0 ;
39569 int res1 = 0 ;
39570 void *argp2 = 0 ;
39571 int res2 = 0 ;
39572 PyObject * obj0 = 0 ;
39573 PyObject * obj1 = 0 ;
39574 char * kwnames[] = {
39575 (char *) "self",(char *) "event", NULL
39576 };
39577
39578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
39579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39580 if (!SWIG_IsOK(res1)) {
39581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
39582 }
39583 arg1 = reinterpret_cast< wxWindow * >(argp1);
39584 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
39585 if (!SWIG_IsOK(res2)) {
39586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39587 }
39588 if (!argp2) {
39589 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39590 }
39591 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
39592 {
39593 PyThreadState* __tstate = wxPyBeginAllowThreads();
39594 (arg1)->OnPaint(*arg2);
39595 wxPyEndAllowThreads(__tstate);
39596 if (PyErr_Occurred()) SWIG_fail;
39597 }
39598 resultobj = SWIG_Py_Void();
39599 return resultobj;
39600 fail:
39601 return NULL;
39602 }
39603
39604
39605 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39606 PyObject *resultobj = 0;
39607 wxWindow *arg1 = (wxWindow *) 0 ;
39608 int arg2 ;
39609 bool result;
39610 void *argp1 = 0 ;
39611 int res1 = 0 ;
39612 int val2 ;
39613 int ecode2 = 0 ;
39614 PyObject * obj0 = 0 ;
39615 PyObject * obj1 = 0 ;
39616 char * kwnames[] = {
39617 (char *) "self",(char *) "orient", NULL
39618 };
39619
39620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39622 if (!SWIG_IsOK(res1)) {
39623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39624 }
39625 arg1 = reinterpret_cast< wxWindow * >(argp1);
39626 ecode2 = SWIG_AsVal_int(obj1, &val2);
39627 if (!SWIG_IsOK(ecode2)) {
39628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39629 }
39630 arg2 = static_cast< int >(val2);
39631 {
39632 PyThreadState* __tstate = wxPyBeginAllowThreads();
39633 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 {
39638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39639 }
39640 return resultobj;
39641 fail:
39642 return NULL;
39643 }
39644
39645
39646 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39647 PyObject *resultobj = 0;
39648 wxWindow *arg1 = (wxWindow *) 0 ;
39649 int arg2 ;
39650 int arg3 ;
39651 int arg4 ;
39652 int arg5 ;
39653 bool arg6 = (bool) true ;
39654 void *argp1 = 0 ;
39655 int res1 = 0 ;
39656 int val2 ;
39657 int ecode2 = 0 ;
39658 int val3 ;
39659 int ecode3 = 0 ;
39660 int val4 ;
39661 int ecode4 = 0 ;
39662 int val5 ;
39663 int ecode5 = 0 ;
39664 bool val6 ;
39665 int ecode6 = 0 ;
39666 PyObject * obj0 = 0 ;
39667 PyObject * obj1 = 0 ;
39668 PyObject * obj2 = 0 ;
39669 PyObject * obj3 = 0 ;
39670 PyObject * obj4 = 0 ;
39671 PyObject * obj5 = 0 ;
39672 char * kwnames[] = {
39673 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39674 };
39675
39676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39678 if (!SWIG_IsOK(res1)) {
39679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39680 }
39681 arg1 = reinterpret_cast< wxWindow * >(argp1);
39682 ecode2 = SWIG_AsVal_int(obj1, &val2);
39683 if (!SWIG_IsOK(ecode2)) {
39684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39685 }
39686 arg2 = static_cast< int >(val2);
39687 ecode3 = SWIG_AsVal_int(obj2, &val3);
39688 if (!SWIG_IsOK(ecode3)) {
39689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39690 }
39691 arg3 = static_cast< int >(val3);
39692 ecode4 = SWIG_AsVal_int(obj3, &val4);
39693 if (!SWIG_IsOK(ecode4)) {
39694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39695 }
39696 arg4 = static_cast< int >(val4);
39697 ecode5 = SWIG_AsVal_int(obj4, &val5);
39698 if (!SWIG_IsOK(ecode5)) {
39699 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39700 }
39701 arg5 = static_cast< int >(val5);
39702 if (obj5) {
39703 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39704 if (!SWIG_IsOK(ecode6)) {
39705 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39706 }
39707 arg6 = static_cast< bool >(val6);
39708 }
39709 {
39710 PyThreadState* __tstate = wxPyBeginAllowThreads();
39711 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39712 wxPyEndAllowThreads(__tstate);
39713 if (PyErr_Occurred()) SWIG_fail;
39714 }
39715 resultobj = SWIG_Py_Void();
39716 return resultobj;
39717 fail:
39718 return NULL;
39719 }
39720
39721
39722 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39723 PyObject *resultobj = 0;
39724 wxWindow *arg1 = (wxWindow *) 0 ;
39725 int arg2 ;
39726 int arg3 ;
39727 bool arg4 = (bool) true ;
39728 void *argp1 = 0 ;
39729 int res1 = 0 ;
39730 int val2 ;
39731 int ecode2 = 0 ;
39732 int val3 ;
39733 int ecode3 = 0 ;
39734 bool val4 ;
39735 int ecode4 = 0 ;
39736 PyObject * obj0 = 0 ;
39737 PyObject * obj1 = 0 ;
39738 PyObject * obj2 = 0 ;
39739 PyObject * obj3 = 0 ;
39740 char * kwnames[] = {
39741 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39742 };
39743
39744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39746 if (!SWIG_IsOK(res1)) {
39747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39748 }
39749 arg1 = reinterpret_cast< wxWindow * >(argp1);
39750 ecode2 = SWIG_AsVal_int(obj1, &val2);
39751 if (!SWIG_IsOK(ecode2)) {
39752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39753 }
39754 arg2 = static_cast< int >(val2);
39755 ecode3 = SWIG_AsVal_int(obj2, &val3);
39756 if (!SWIG_IsOK(ecode3)) {
39757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39758 }
39759 arg3 = static_cast< int >(val3);
39760 if (obj3) {
39761 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39762 if (!SWIG_IsOK(ecode4)) {
39763 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39764 }
39765 arg4 = static_cast< bool >(val4);
39766 }
39767 {
39768 PyThreadState* __tstate = wxPyBeginAllowThreads();
39769 (arg1)->SetScrollPos(arg2,arg3,arg4);
39770 wxPyEndAllowThreads(__tstate);
39771 if (PyErr_Occurred()) SWIG_fail;
39772 }
39773 resultobj = SWIG_Py_Void();
39774 return resultobj;
39775 fail:
39776 return NULL;
39777 }
39778
39779
39780 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39781 PyObject *resultobj = 0;
39782 wxWindow *arg1 = (wxWindow *) 0 ;
39783 int arg2 ;
39784 int result;
39785 void *argp1 = 0 ;
39786 int res1 = 0 ;
39787 int val2 ;
39788 int ecode2 = 0 ;
39789 PyObject * obj0 = 0 ;
39790 PyObject * obj1 = 0 ;
39791 char * kwnames[] = {
39792 (char *) "self",(char *) "orientation", NULL
39793 };
39794
39795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39797 if (!SWIG_IsOK(res1)) {
39798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39799 }
39800 arg1 = reinterpret_cast< wxWindow * >(argp1);
39801 ecode2 = SWIG_AsVal_int(obj1, &val2);
39802 if (!SWIG_IsOK(ecode2)) {
39803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39804 }
39805 arg2 = static_cast< int >(val2);
39806 {
39807 PyThreadState* __tstate = wxPyBeginAllowThreads();
39808 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39809 wxPyEndAllowThreads(__tstate);
39810 if (PyErr_Occurred()) SWIG_fail;
39811 }
39812 resultobj = SWIG_From_int(static_cast< int >(result));
39813 return resultobj;
39814 fail:
39815 return NULL;
39816 }
39817
39818
39819 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39820 PyObject *resultobj = 0;
39821 wxWindow *arg1 = (wxWindow *) 0 ;
39822 int arg2 ;
39823 int result;
39824 void *argp1 = 0 ;
39825 int res1 = 0 ;
39826 int val2 ;
39827 int ecode2 = 0 ;
39828 PyObject * obj0 = 0 ;
39829 PyObject * obj1 = 0 ;
39830 char * kwnames[] = {
39831 (char *) "self",(char *) "orientation", NULL
39832 };
39833
39834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39836 if (!SWIG_IsOK(res1)) {
39837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39838 }
39839 arg1 = reinterpret_cast< wxWindow * >(argp1);
39840 ecode2 = SWIG_AsVal_int(obj1, &val2);
39841 if (!SWIG_IsOK(ecode2)) {
39842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39843 }
39844 arg2 = static_cast< int >(val2);
39845 {
39846 PyThreadState* __tstate = wxPyBeginAllowThreads();
39847 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39848 wxPyEndAllowThreads(__tstate);
39849 if (PyErr_Occurred()) SWIG_fail;
39850 }
39851 resultobj = SWIG_From_int(static_cast< int >(result));
39852 return resultobj;
39853 fail:
39854 return NULL;
39855 }
39856
39857
39858 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39859 PyObject *resultobj = 0;
39860 wxWindow *arg1 = (wxWindow *) 0 ;
39861 int arg2 ;
39862 int result;
39863 void *argp1 = 0 ;
39864 int res1 = 0 ;
39865 int val2 ;
39866 int ecode2 = 0 ;
39867 PyObject * obj0 = 0 ;
39868 PyObject * obj1 = 0 ;
39869 char * kwnames[] = {
39870 (char *) "self",(char *) "orientation", NULL
39871 };
39872
39873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39875 if (!SWIG_IsOK(res1)) {
39876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39877 }
39878 arg1 = reinterpret_cast< wxWindow * >(argp1);
39879 ecode2 = SWIG_AsVal_int(obj1, &val2);
39880 if (!SWIG_IsOK(ecode2)) {
39881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39882 }
39883 arg2 = static_cast< int >(val2);
39884 {
39885 PyThreadState* __tstate = wxPyBeginAllowThreads();
39886 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39887 wxPyEndAllowThreads(__tstate);
39888 if (PyErr_Occurred()) SWIG_fail;
39889 }
39890 resultobj = SWIG_From_int(static_cast< int >(result));
39891 return resultobj;
39892 fail:
39893 return NULL;
39894 }
39895
39896
39897 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39898 PyObject *resultobj = 0;
39899 wxWindow *arg1 = (wxWindow *) 0 ;
39900 int arg2 ;
39901 int arg3 ;
39902 wxRect *arg4 = (wxRect *) NULL ;
39903 void *argp1 = 0 ;
39904 int res1 = 0 ;
39905 int val2 ;
39906 int ecode2 = 0 ;
39907 int val3 ;
39908 int ecode3 = 0 ;
39909 void *argp4 = 0 ;
39910 int res4 = 0 ;
39911 PyObject * obj0 = 0 ;
39912 PyObject * obj1 = 0 ;
39913 PyObject * obj2 = 0 ;
39914 PyObject * obj3 = 0 ;
39915 char * kwnames[] = {
39916 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39917 };
39918
39919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39921 if (!SWIG_IsOK(res1)) {
39922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39923 }
39924 arg1 = reinterpret_cast< wxWindow * >(argp1);
39925 ecode2 = SWIG_AsVal_int(obj1, &val2);
39926 if (!SWIG_IsOK(ecode2)) {
39927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39928 }
39929 arg2 = static_cast< int >(val2);
39930 ecode3 = SWIG_AsVal_int(obj2, &val3);
39931 if (!SWIG_IsOK(ecode3)) {
39932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39933 }
39934 arg3 = static_cast< int >(val3);
39935 if (obj3) {
39936 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39937 if (!SWIG_IsOK(res4)) {
39938 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39939 }
39940 arg4 = reinterpret_cast< wxRect * >(argp4);
39941 }
39942 {
39943 PyThreadState* __tstate = wxPyBeginAllowThreads();
39944 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39945 wxPyEndAllowThreads(__tstate);
39946 if (PyErr_Occurred()) SWIG_fail;
39947 }
39948 resultobj = SWIG_Py_Void();
39949 return resultobj;
39950 fail:
39951 return NULL;
39952 }
39953
39954
39955 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39956 PyObject *resultobj = 0;
39957 wxWindow *arg1 = (wxWindow *) 0 ;
39958 int arg2 ;
39959 bool result;
39960 void *argp1 = 0 ;
39961 int res1 = 0 ;
39962 int val2 ;
39963 int ecode2 = 0 ;
39964 PyObject * obj0 = 0 ;
39965 PyObject * obj1 = 0 ;
39966 char * kwnames[] = {
39967 (char *) "self",(char *) "lines", NULL
39968 };
39969
39970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
39971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39972 if (!SWIG_IsOK(res1)) {
39973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
39974 }
39975 arg1 = reinterpret_cast< wxWindow * >(argp1);
39976 ecode2 = SWIG_AsVal_int(obj1, &val2);
39977 if (!SWIG_IsOK(ecode2)) {
39978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
39979 }
39980 arg2 = static_cast< int >(val2);
39981 {
39982 PyThreadState* __tstate = wxPyBeginAllowThreads();
39983 result = (bool)(arg1)->ScrollLines(arg2);
39984 wxPyEndAllowThreads(__tstate);
39985 if (PyErr_Occurred()) SWIG_fail;
39986 }
39987 {
39988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39989 }
39990 return resultobj;
39991 fail:
39992 return NULL;
39993 }
39994
39995
39996 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39997 PyObject *resultobj = 0;
39998 wxWindow *arg1 = (wxWindow *) 0 ;
39999 int arg2 ;
40000 bool result;
40001 void *argp1 = 0 ;
40002 int res1 = 0 ;
40003 int val2 ;
40004 int ecode2 = 0 ;
40005 PyObject * obj0 = 0 ;
40006 PyObject * obj1 = 0 ;
40007 char * kwnames[] = {
40008 (char *) "self",(char *) "pages", NULL
40009 };
40010
40011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40013 if (!SWIG_IsOK(res1)) {
40014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40015 }
40016 arg1 = reinterpret_cast< wxWindow * >(argp1);
40017 ecode2 = SWIG_AsVal_int(obj1, &val2);
40018 if (!SWIG_IsOK(ecode2)) {
40019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40020 }
40021 arg2 = static_cast< int >(val2);
40022 {
40023 PyThreadState* __tstate = wxPyBeginAllowThreads();
40024 result = (bool)(arg1)->ScrollPages(arg2);
40025 wxPyEndAllowThreads(__tstate);
40026 if (PyErr_Occurred()) SWIG_fail;
40027 }
40028 {
40029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40030 }
40031 return resultobj;
40032 fail:
40033 return NULL;
40034 }
40035
40036
40037 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40038 PyObject *resultobj = 0;
40039 wxWindow *arg1 = (wxWindow *) 0 ;
40040 bool result;
40041 void *argp1 = 0 ;
40042 int res1 = 0 ;
40043 PyObject *swig_obj[1] ;
40044
40045 if (!args) SWIG_fail;
40046 swig_obj[0] = args;
40047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40048 if (!SWIG_IsOK(res1)) {
40049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40050 }
40051 arg1 = reinterpret_cast< wxWindow * >(argp1);
40052 {
40053 PyThreadState* __tstate = wxPyBeginAllowThreads();
40054 result = (bool)(arg1)->LineUp();
40055 wxPyEndAllowThreads(__tstate);
40056 if (PyErr_Occurred()) SWIG_fail;
40057 }
40058 {
40059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40060 }
40061 return resultobj;
40062 fail:
40063 return NULL;
40064 }
40065
40066
40067 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40068 PyObject *resultobj = 0;
40069 wxWindow *arg1 = (wxWindow *) 0 ;
40070 bool result;
40071 void *argp1 = 0 ;
40072 int res1 = 0 ;
40073 PyObject *swig_obj[1] ;
40074
40075 if (!args) SWIG_fail;
40076 swig_obj[0] = args;
40077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40078 if (!SWIG_IsOK(res1)) {
40079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40080 }
40081 arg1 = reinterpret_cast< wxWindow * >(argp1);
40082 {
40083 PyThreadState* __tstate = wxPyBeginAllowThreads();
40084 result = (bool)(arg1)->LineDown();
40085 wxPyEndAllowThreads(__tstate);
40086 if (PyErr_Occurred()) SWIG_fail;
40087 }
40088 {
40089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40090 }
40091 return resultobj;
40092 fail:
40093 return NULL;
40094 }
40095
40096
40097 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40098 PyObject *resultobj = 0;
40099 wxWindow *arg1 = (wxWindow *) 0 ;
40100 bool result;
40101 void *argp1 = 0 ;
40102 int res1 = 0 ;
40103 PyObject *swig_obj[1] ;
40104
40105 if (!args) SWIG_fail;
40106 swig_obj[0] = args;
40107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40108 if (!SWIG_IsOK(res1)) {
40109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40110 }
40111 arg1 = reinterpret_cast< wxWindow * >(argp1);
40112 {
40113 PyThreadState* __tstate = wxPyBeginAllowThreads();
40114 result = (bool)(arg1)->PageUp();
40115 wxPyEndAllowThreads(__tstate);
40116 if (PyErr_Occurred()) SWIG_fail;
40117 }
40118 {
40119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40120 }
40121 return resultobj;
40122 fail:
40123 return NULL;
40124 }
40125
40126
40127 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40128 PyObject *resultobj = 0;
40129 wxWindow *arg1 = (wxWindow *) 0 ;
40130 bool result;
40131 void *argp1 = 0 ;
40132 int res1 = 0 ;
40133 PyObject *swig_obj[1] ;
40134
40135 if (!args) SWIG_fail;
40136 swig_obj[0] = args;
40137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40138 if (!SWIG_IsOK(res1)) {
40139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40140 }
40141 arg1 = reinterpret_cast< wxWindow * >(argp1);
40142 {
40143 PyThreadState* __tstate = wxPyBeginAllowThreads();
40144 result = (bool)(arg1)->PageDown();
40145 wxPyEndAllowThreads(__tstate);
40146 if (PyErr_Occurred()) SWIG_fail;
40147 }
40148 {
40149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40150 }
40151 return resultobj;
40152 fail:
40153 return NULL;
40154 }
40155
40156
40157 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40158 PyObject *resultobj = 0;
40159 wxWindow *arg1 = (wxWindow *) 0 ;
40160 wxString *arg2 = 0 ;
40161 void *argp1 = 0 ;
40162 int res1 = 0 ;
40163 bool temp2 = false ;
40164 PyObject * obj0 = 0 ;
40165 PyObject * obj1 = 0 ;
40166 char * kwnames[] = {
40167 (char *) "self",(char *) "text", NULL
40168 };
40169
40170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40172 if (!SWIG_IsOK(res1)) {
40173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40174 }
40175 arg1 = reinterpret_cast< wxWindow * >(argp1);
40176 {
40177 arg2 = wxString_in_helper(obj1);
40178 if (arg2 == NULL) SWIG_fail;
40179 temp2 = true;
40180 }
40181 {
40182 PyThreadState* __tstate = wxPyBeginAllowThreads();
40183 (arg1)->SetHelpText((wxString const &)*arg2);
40184 wxPyEndAllowThreads(__tstate);
40185 if (PyErr_Occurred()) SWIG_fail;
40186 }
40187 resultobj = SWIG_Py_Void();
40188 {
40189 if (temp2)
40190 delete arg2;
40191 }
40192 return resultobj;
40193 fail:
40194 {
40195 if (temp2)
40196 delete arg2;
40197 }
40198 return NULL;
40199 }
40200
40201
40202 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40203 PyObject *resultobj = 0;
40204 wxWindow *arg1 = (wxWindow *) 0 ;
40205 wxString *arg2 = 0 ;
40206 void *argp1 = 0 ;
40207 int res1 = 0 ;
40208 bool temp2 = false ;
40209 PyObject * obj0 = 0 ;
40210 PyObject * obj1 = 0 ;
40211 char * kwnames[] = {
40212 (char *) "self",(char *) "text", NULL
40213 };
40214
40215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40217 if (!SWIG_IsOK(res1)) {
40218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40219 }
40220 arg1 = reinterpret_cast< wxWindow * >(argp1);
40221 {
40222 arg2 = wxString_in_helper(obj1);
40223 if (arg2 == NULL) SWIG_fail;
40224 temp2 = true;
40225 }
40226 {
40227 PyThreadState* __tstate = wxPyBeginAllowThreads();
40228 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40229 wxPyEndAllowThreads(__tstate);
40230 if (PyErr_Occurred()) SWIG_fail;
40231 }
40232 resultobj = SWIG_Py_Void();
40233 {
40234 if (temp2)
40235 delete arg2;
40236 }
40237 return resultobj;
40238 fail:
40239 {
40240 if (temp2)
40241 delete arg2;
40242 }
40243 return NULL;
40244 }
40245
40246
40247 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40248 PyObject *resultobj = 0;
40249 wxWindow *arg1 = (wxWindow *) 0 ;
40250 wxPoint *arg2 = 0 ;
40251 wxHelpEvent::Origin arg3 ;
40252 wxString result;
40253 void *argp1 = 0 ;
40254 int res1 = 0 ;
40255 wxPoint temp2 ;
40256 void *argp3 ;
40257 int res3 = 0 ;
40258 PyObject * obj0 = 0 ;
40259 PyObject * obj1 = 0 ;
40260 PyObject * obj2 = 0 ;
40261 char * kwnames[] = {
40262 (char *) "self",(char *) "pt",(char *) "origin", NULL
40263 };
40264
40265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40267 if (!SWIG_IsOK(res1)) {
40268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40269 }
40270 arg1 = reinterpret_cast< wxWindow * >(argp1);
40271 {
40272 arg2 = &temp2;
40273 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40274 }
40275 {
40276 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40277 if (!SWIG_IsOK(res3)) {
40278 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40279 }
40280 if (!argp3) {
40281 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40282 } else {
40283 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40284 arg3 = *temp;
40285 if (SWIG_IsNewObj(res3)) delete temp;
40286 }
40287 }
40288 {
40289 PyThreadState* __tstate = wxPyBeginAllowThreads();
40290 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40291 wxPyEndAllowThreads(__tstate);
40292 if (PyErr_Occurred()) SWIG_fail;
40293 }
40294 {
40295 #if wxUSE_UNICODE
40296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40297 #else
40298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40299 #endif
40300 }
40301 return resultobj;
40302 fail:
40303 return NULL;
40304 }
40305
40306
40307 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40308 PyObject *resultobj = 0;
40309 wxWindow *arg1 = (wxWindow *) 0 ;
40310 wxString result;
40311 void *argp1 = 0 ;
40312 int res1 = 0 ;
40313 PyObject *swig_obj[1] ;
40314
40315 if (!args) SWIG_fail;
40316 swig_obj[0] = args;
40317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40318 if (!SWIG_IsOK(res1)) {
40319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40320 }
40321 arg1 = reinterpret_cast< wxWindow * >(argp1);
40322 {
40323 PyThreadState* __tstate = wxPyBeginAllowThreads();
40324 result = ((wxWindow const *)arg1)->GetHelpText();
40325 wxPyEndAllowThreads(__tstate);
40326 if (PyErr_Occurred()) SWIG_fail;
40327 }
40328 {
40329 #if wxUSE_UNICODE
40330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40331 #else
40332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40333 #endif
40334 }
40335 return resultobj;
40336 fail:
40337 return NULL;
40338 }
40339
40340
40341 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40342 PyObject *resultobj = 0;
40343 wxWindow *arg1 = (wxWindow *) 0 ;
40344 wxString *arg2 = 0 ;
40345 void *argp1 = 0 ;
40346 int res1 = 0 ;
40347 bool temp2 = false ;
40348 PyObject * obj0 = 0 ;
40349 PyObject * obj1 = 0 ;
40350 char * kwnames[] = {
40351 (char *) "self",(char *) "tip", NULL
40352 };
40353
40354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40356 if (!SWIG_IsOK(res1)) {
40357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40358 }
40359 arg1 = reinterpret_cast< wxWindow * >(argp1);
40360 {
40361 arg2 = wxString_in_helper(obj1);
40362 if (arg2 == NULL) SWIG_fail;
40363 temp2 = true;
40364 }
40365 {
40366 PyThreadState* __tstate = wxPyBeginAllowThreads();
40367 (arg1)->SetToolTip((wxString const &)*arg2);
40368 wxPyEndAllowThreads(__tstate);
40369 if (PyErr_Occurred()) SWIG_fail;
40370 }
40371 resultobj = SWIG_Py_Void();
40372 {
40373 if (temp2)
40374 delete arg2;
40375 }
40376 return resultobj;
40377 fail:
40378 {
40379 if (temp2)
40380 delete arg2;
40381 }
40382 return NULL;
40383 }
40384
40385
40386 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40387 PyObject *resultobj = 0;
40388 wxWindow *arg1 = (wxWindow *) 0 ;
40389 wxToolTip *arg2 = (wxToolTip *) 0 ;
40390 void *argp1 = 0 ;
40391 int res1 = 0 ;
40392 int res2 = 0 ;
40393 PyObject * obj0 = 0 ;
40394 PyObject * obj1 = 0 ;
40395 char * kwnames[] = {
40396 (char *) "self",(char *) "tip", NULL
40397 };
40398
40399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40401 if (!SWIG_IsOK(res1)) {
40402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40403 }
40404 arg1 = reinterpret_cast< wxWindow * >(argp1);
40405 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40406 if (!SWIG_IsOK(res2)) {
40407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40408 }
40409 {
40410 PyThreadState* __tstate = wxPyBeginAllowThreads();
40411 (arg1)->SetToolTip(arg2);
40412 wxPyEndAllowThreads(__tstate);
40413 if (PyErr_Occurred()) SWIG_fail;
40414 }
40415 resultobj = SWIG_Py_Void();
40416 return resultobj;
40417 fail:
40418 return NULL;
40419 }
40420
40421
40422 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40423 PyObject *resultobj = 0;
40424 wxWindow *arg1 = (wxWindow *) 0 ;
40425 wxToolTip *result = 0 ;
40426 void *argp1 = 0 ;
40427 int res1 = 0 ;
40428 PyObject *swig_obj[1] ;
40429
40430 if (!args) SWIG_fail;
40431 swig_obj[0] = args;
40432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40433 if (!SWIG_IsOK(res1)) {
40434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40435 }
40436 arg1 = reinterpret_cast< wxWindow * >(argp1);
40437 {
40438 PyThreadState* __tstate = wxPyBeginAllowThreads();
40439 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40440 wxPyEndAllowThreads(__tstate);
40441 if (PyErr_Occurred()) SWIG_fail;
40442 }
40443 {
40444 resultobj = wxPyMake_wxObject(result, (bool)0);
40445 }
40446 return resultobj;
40447 fail:
40448 return NULL;
40449 }
40450
40451
40452 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40453 PyObject *resultobj = 0;
40454 wxWindow *arg1 = (wxWindow *) 0 ;
40455 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40456 void *argp1 = 0 ;
40457 int res1 = 0 ;
40458 int res2 = 0 ;
40459 PyObject * obj0 = 0 ;
40460 PyObject * obj1 = 0 ;
40461 char * kwnames[] = {
40462 (char *) "self",(char *) "dropTarget", NULL
40463 };
40464
40465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40467 if (!SWIG_IsOK(res1)) {
40468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40469 }
40470 arg1 = reinterpret_cast< wxWindow * >(argp1);
40471 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40472 if (!SWIG_IsOK(res2)) {
40473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40474 }
40475 {
40476 PyThreadState* __tstate = wxPyBeginAllowThreads();
40477 (arg1)->SetDropTarget(arg2);
40478 wxPyEndAllowThreads(__tstate);
40479 if (PyErr_Occurred()) SWIG_fail;
40480 }
40481 resultobj = SWIG_Py_Void();
40482 return resultobj;
40483 fail:
40484 return NULL;
40485 }
40486
40487
40488 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40489 PyObject *resultobj = 0;
40490 wxWindow *arg1 = (wxWindow *) 0 ;
40491 wxPyDropTarget *result = 0 ;
40492 void *argp1 = 0 ;
40493 int res1 = 0 ;
40494 PyObject *swig_obj[1] ;
40495
40496 if (!args) SWIG_fail;
40497 swig_obj[0] = args;
40498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40499 if (!SWIG_IsOK(res1)) {
40500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40501 }
40502 arg1 = reinterpret_cast< wxWindow * >(argp1);
40503 {
40504 PyThreadState* __tstate = wxPyBeginAllowThreads();
40505 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40506 wxPyEndAllowThreads(__tstate);
40507 if (PyErr_Occurred()) SWIG_fail;
40508 }
40509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40510 return resultobj;
40511 fail:
40512 return NULL;
40513 }
40514
40515
40516 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40517 PyObject *resultobj = 0;
40518 wxWindow *arg1 = (wxWindow *) 0 ;
40519 bool arg2 ;
40520 void *argp1 = 0 ;
40521 int res1 = 0 ;
40522 bool val2 ;
40523 int ecode2 = 0 ;
40524 PyObject * obj0 = 0 ;
40525 PyObject * obj1 = 0 ;
40526 char * kwnames[] = {
40527 (char *) "self",(char *) "accept", NULL
40528 };
40529
40530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40532 if (!SWIG_IsOK(res1)) {
40533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40534 }
40535 arg1 = reinterpret_cast< wxWindow * >(argp1);
40536 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40537 if (!SWIG_IsOK(ecode2)) {
40538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40539 }
40540 arg2 = static_cast< bool >(val2);
40541 {
40542 PyThreadState* __tstate = wxPyBeginAllowThreads();
40543 (arg1)->DragAcceptFiles(arg2);
40544 wxPyEndAllowThreads(__tstate);
40545 if (PyErr_Occurred()) SWIG_fail;
40546 }
40547 resultobj = SWIG_Py_Void();
40548 return resultobj;
40549 fail:
40550 return NULL;
40551 }
40552
40553
40554 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40555 PyObject *resultobj = 0;
40556 wxWindow *arg1 = (wxWindow *) 0 ;
40557 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40558 void *argp1 = 0 ;
40559 int res1 = 0 ;
40560 int res2 = 0 ;
40561 PyObject * obj0 = 0 ;
40562 PyObject * obj1 = 0 ;
40563 char * kwnames[] = {
40564 (char *) "self",(char *) "constraints", NULL
40565 };
40566
40567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40569 if (!SWIG_IsOK(res1)) {
40570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40571 }
40572 arg1 = reinterpret_cast< wxWindow * >(argp1);
40573 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40574 if (!SWIG_IsOK(res2)) {
40575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40576 }
40577 {
40578 PyThreadState* __tstate = wxPyBeginAllowThreads();
40579 (arg1)->SetConstraints(arg2);
40580 wxPyEndAllowThreads(__tstate);
40581 if (PyErr_Occurred()) SWIG_fail;
40582 }
40583 resultobj = SWIG_Py_Void();
40584 return resultobj;
40585 fail:
40586 return NULL;
40587 }
40588
40589
40590 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40591 PyObject *resultobj = 0;
40592 wxWindow *arg1 = (wxWindow *) 0 ;
40593 wxLayoutConstraints *result = 0 ;
40594 void *argp1 = 0 ;
40595 int res1 = 0 ;
40596 PyObject *swig_obj[1] ;
40597
40598 if (!args) SWIG_fail;
40599 swig_obj[0] = args;
40600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40601 if (!SWIG_IsOK(res1)) {
40602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40603 }
40604 arg1 = reinterpret_cast< wxWindow * >(argp1);
40605 {
40606 PyThreadState* __tstate = wxPyBeginAllowThreads();
40607 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40608 wxPyEndAllowThreads(__tstate);
40609 if (PyErr_Occurred()) SWIG_fail;
40610 }
40611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40612 return resultobj;
40613 fail:
40614 return NULL;
40615 }
40616
40617
40618 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40619 PyObject *resultobj = 0;
40620 wxWindow *arg1 = (wxWindow *) 0 ;
40621 bool arg2 ;
40622 void *argp1 = 0 ;
40623 int res1 = 0 ;
40624 bool val2 ;
40625 int ecode2 = 0 ;
40626 PyObject * obj0 = 0 ;
40627 PyObject * obj1 = 0 ;
40628 char * kwnames[] = {
40629 (char *) "self",(char *) "autoLayout", NULL
40630 };
40631
40632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40634 if (!SWIG_IsOK(res1)) {
40635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40636 }
40637 arg1 = reinterpret_cast< wxWindow * >(argp1);
40638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40639 if (!SWIG_IsOK(ecode2)) {
40640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40641 }
40642 arg2 = static_cast< bool >(val2);
40643 {
40644 PyThreadState* __tstate = wxPyBeginAllowThreads();
40645 (arg1)->SetAutoLayout(arg2);
40646 wxPyEndAllowThreads(__tstate);
40647 if (PyErr_Occurred()) SWIG_fail;
40648 }
40649 resultobj = SWIG_Py_Void();
40650 return resultobj;
40651 fail:
40652 return NULL;
40653 }
40654
40655
40656 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40657 PyObject *resultobj = 0;
40658 wxWindow *arg1 = (wxWindow *) 0 ;
40659 bool result;
40660 void *argp1 = 0 ;
40661 int res1 = 0 ;
40662 PyObject *swig_obj[1] ;
40663
40664 if (!args) SWIG_fail;
40665 swig_obj[0] = args;
40666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40667 if (!SWIG_IsOK(res1)) {
40668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40669 }
40670 arg1 = reinterpret_cast< wxWindow * >(argp1);
40671 {
40672 PyThreadState* __tstate = wxPyBeginAllowThreads();
40673 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40674 wxPyEndAllowThreads(__tstate);
40675 if (PyErr_Occurred()) SWIG_fail;
40676 }
40677 {
40678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40679 }
40680 return resultobj;
40681 fail:
40682 return NULL;
40683 }
40684
40685
40686 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40687 PyObject *resultobj = 0;
40688 wxWindow *arg1 = (wxWindow *) 0 ;
40689 bool result;
40690 void *argp1 = 0 ;
40691 int res1 = 0 ;
40692 PyObject *swig_obj[1] ;
40693
40694 if (!args) SWIG_fail;
40695 swig_obj[0] = args;
40696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40697 if (!SWIG_IsOK(res1)) {
40698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40699 }
40700 arg1 = reinterpret_cast< wxWindow * >(argp1);
40701 {
40702 PyThreadState* __tstate = wxPyBeginAllowThreads();
40703 result = (bool)(arg1)->Layout();
40704 wxPyEndAllowThreads(__tstate);
40705 if (PyErr_Occurred()) SWIG_fail;
40706 }
40707 {
40708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40709 }
40710 return resultobj;
40711 fail:
40712 return NULL;
40713 }
40714
40715
40716 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40717 PyObject *resultobj = 0;
40718 wxWindow *arg1 = (wxWindow *) 0 ;
40719 wxSizer *arg2 = (wxSizer *) 0 ;
40720 bool arg3 = (bool) true ;
40721 void *argp1 = 0 ;
40722 int res1 = 0 ;
40723 int res2 = 0 ;
40724 bool val3 ;
40725 int ecode3 = 0 ;
40726 PyObject * obj0 = 0 ;
40727 PyObject * obj1 = 0 ;
40728 PyObject * obj2 = 0 ;
40729 char * kwnames[] = {
40730 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40731 };
40732
40733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40735 if (!SWIG_IsOK(res1)) {
40736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40737 }
40738 arg1 = reinterpret_cast< wxWindow * >(argp1);
40739 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40740 if (!SWIG_IsOK(res2)) {
40741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40742 }
40743 if (obj2) {
40744 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40745 if (!SWIG_IsOK(ecode3)) {
40746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40747 }
40748 arg3 = static_cast< bool >(val3);
40749 }
40750 {
40751 PyThreadState* __tstate = wxPyBeginAllowThreads();
40752 (arg1)->SetSizer(arg2,arg3);
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 resultobj = SWIG_Py_Void();
40757 return resultobj;
40758 fail:
40759 return NULL;
40760 }
40761
40762
40763 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40764 PyObject *resultobj = 0;
40765 wxWindow *arg1 = (wxWindow *) 0 ;
40766 wxSizer *arg2 = (wxSizer *) 0 ;
40767 bool arg3 = (bool) true ;
40768 void *argp1 = 0 ;
40769 int res1 = 0 ;
40770 int res2 = 0 ;
40771 bool val3 ;
40772 int ecode3 = 0 ;
40773 PyObject * obj0 = 0 ;
40774 PyObject * obj1 = 0 ;
40775 PyObject * obj2 = 0 ;
40776 char * kwnames[] = {
40777 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40778 };
40779
40780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40782 if (!SWIG_IsOK(res1)) {
40783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40784 }
40785 arg1 = reinterpret_cast< wxWindow * >(argp1);
40786 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40787 if (!SWIG_IsOK(res2)) {
40788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40789 }
40790 if (obj2) {
40791 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40792 if (!SWIG_IsOK(ecode3)) {
40793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40794 }
40795 arg3 = static_cast< bool >(val3);
40796 }
40797 {
40798 PyThreadState* __tstate = wxPyBeginAllowThreads();
40799 (arg1)->SetSizerAndFit(arg2,arg3);
40800 wxPyEndAllowThreads(__tstate);
40801 if (PyErr_Occurred()) SWIG_fail;
40802 }
40803 resultobj = SWIG_Py_Void();
40804 return resultobj;
40805 fail:
40806 return NULL;
40807 }
40808
40809
40810 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40811 PyObject *resultobj = 0;
40812 wxWindow *arg1 = (wxWindow *) 0 ;
40813 wxSizer *result = 0 ;
40814 void *argp1 = 0 ;
40815 int res1 = 0 ;
40816 PyObject *swig_obj[1] ;
40817
40818 if (!args) SWIG_fail;
40819 swig_obj[0] = args;
40820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40821 if (!SWIG_IsOK(res1)) {
40822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40823 }
40824 arg1 = reinterpret_cast< wxWindow * >(argp1);
40825 {
40826 PyThreadState* __tstate = wxPyBeginAllowThreads();
40827 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40828 wxPyEndAllowThreads(__tstate);
40829 if (PyErr_Occurred()) SWIG_fail;
40830 }
40831 {
40832 resultobj = wxPyMake_wxObject(result, (bool)0);
40833 }
40834 return resultobj;
40835 fail:
40836 return NULL;
40837 }
40838
40839
40840 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40841 PyObject *resultobj = 0;
40842 wxWindow *arg1 = (wxWindow *) 0 ;
40843 wxSizer *arg2 = (wxSizer *) 0 ;
40844 void *argp1 = 0 ;
40845 int res1 = 0 ;
40846 void *argp2 = 0 ;
40847 int res2 = 0 ;
40848 PyObject * obj0 = 0 ;
40849 PyObject * obj1 = 0 ;
40850 char * kwnames[] = {
40851 (char *) "self",(char *) "sizer", NULL
40852 };
40853
40854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40856 if (!SWIG_IsOK(res1)) {
40857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40858 }
40859 arg1 = reinterpret_cast< wxWindow * >(argp1);
40860 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40861 if (!SWIG_IsOK(res2)) {
40862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40863 }
40864 arg2 = reinterpret_cast< wxSizer * >(argp2);
40865 {
40866 PyThreadState* __tstate = wxPyBeginAllowThreads();
40867 (arg1)->SetContainingSizer(arg2);
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 resultobj = SWIG_Py_Void();
40872 return resultobj;
40873 fail:
40874 return NULL;
40875 }
40876
40877
40878 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40879 PyObject *resultobj = 0;
40880 wxWindow *arg1 = (wxWindow *) 0 ;
40881 wxSizer *result = 0 ;
40882 void *argp1 = 0 ;
40883 int res1 = 0 ;
40884 PyObject *swig_obj[1] ;
40885
40886 if (!args) SWIG_fail;
40887 swig_obj[0] = args;
40888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40889 if (!SWIG_IsOK(res1)) {
40890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40891 }
40892 arg1 = reinterpret_cast< wxWindow * >(argp1);
40893 {
40894 PyThreadState* __tstate = wxPyBeginAllowThreads();
40895 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40896 wxPyEndAllowThreads(__tstate);
40897 if (PyErr_Occurred()) SWIG_fail;
40898 }
40899 {
40900 resultobj = wxPyMake_wxObject(result, (bool)0);
40901 }
40902 return resultobj;
40903 fail:
40904 return NULL;
40905 }
40906
40907
40908 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40909 PyObject *resultobj = 0;
40910 wxWindow *arg1 = (wxWindow *) 0 ;
40911 void *argp1 = 0 ;
40912 int res1 = 0 ;
40913 PyObject *swig_obj[1] ;
40914
40915 if (!args) SWIG_fail;
40916 swig_obj[0] = args;
40917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40918 if (!SWIG_IsOK(res1)) {
40919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40920 }
40921 arg1 = reinterpret_cast< wxWindow * >(argp1);
40922 {
40923 PyThreadState* __tstate = wxPyBeginAllowThreads();
40924 (arg1)->InheritAttributes();
40925 wxPyEndAllowThreads(__tstate);
40926 if (PyErr_Occurred()) SWIG_fail;
40927 }
40928 resultobj = SWIG_Py_Void();
40929 return resultobj;
40930 fail:
40931 return NULL;
40932 }
40933
40934
40935 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40936 PyObject *resultobj = 0;
40937 wxWindow *arg1 = (wxWindow *) 0 ;
40938 bool result;
40939 void *argp1 = 0 ;
40940 int res1 = 0 ;
40941 PyObject *swig_obj[1] ;
40942
40943 if (!args) SWIG_fail;
40944 swig_obj[0] = args;
40945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40946 if (!SWIG_IsOK(res1)) {
40947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40948 }
40949 arg1 = reinterpret_cast< wxWindow * >(argp1);
40950 {
40951 PyThreadState* __tstate = wxPyBeginAllowThreads();
40952 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40953 wxPyEndAllowThreads(__tstate);
40954 if (PyErr_Occurred()) SWIG_fail;
40955 }
40956 {
40957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40958 }
40959 return resultobj;
40960 fail:
40961 return NULL;
40962 }
40963
40964
40965 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40966 PyObject *resultobj = 0;
40967 wxWindow *arg1 = (wxWindow *) 0 ;
40968 bool result;
40969 void *argp1 = 0 ;
40970 int res1 = 0 ;
40971 PyObject *swig_obj[1] ;
40972
40973 if (!args) SWIG_fail;
40974 swig_obj[0] = args;
40975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40976 if (!SWIG_IsOK(res1)) {
40977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40978 }
40979 arg1 = reinterpret_cast< wxWindow * >(argp1);
40980 {
40981 PyThreadState* __tstate = wxPyBeginAllowThreads();
40982 result = (bool)(arg1)->CanSetTransparent();
40983 wxPyEndAllowThreads(__tstate);
40984 if (PyErr_Occurred()) SWIG_fail;
40985 }
40986 {
40987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40988 }
40989 return resultobj;
40990 fail:
40991 return NULL;
40992 }
40993
40994
40995 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40996 PyObject *resultobj = 0;
40997 wxWindow *arg1 = (wxWindow *) 0 ;
40998 byte arg2 ;
40999 bool result;
41000 void *argp1 = 0 ;
41001 int res1 = 0 ;
41002 unsigned char val2 ;
41003 int ecode2 = 0 ;
41004 PyObject * obj0 = 0 ;
41005 PyObject * obj1 = 0 ;
41006 char * kwnames[] = {
41007 (char *) "self",(char *) "alpha", NULL
41008 };
41009
41010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41012 if (!SWIG_IsOK(res1)) {
41013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41014 }
41015 arg1 = reinterpret_cast< wxWindow * >(argp1);
41016 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41017 if (!SWIG_IsOK(ecode2)) {
41018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41019 }
41020 arg2 = static_cast< byte >(val2);
41021 {
41022 PyThreadState* __tstate = wxPyBeginAllowThreads();
41023 result = (bool)(arg1)->SetTransparent(arg2);
41024 wxPyEndAllowThreads(__tstate);
41025 if (PyErr_Occurred()) SWIG_fail;
41026 }
41027 {
41028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41029 }
41030 return resultobj;
41031 fail:
41032 return NULL;
41033 }
41034
41035
41036 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41037 PyObject *obj;
41038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41039 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41040 return SWIG_Py_Void();
41041 }
41042
41043 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41044 return SWIG_Python_InitShadowInstance(args);
41045 }
41046
41047 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41048 PyObject *resultobj = 0;
41049 long arg1 ;
41050 wxWindow *arg2 = (wxWindow *) NULL ;
41051 wxWindow *result = 0 ;
41052 long val1 ;
41053 int ecode1 = 0 ;
41054 void *argp2 = 0 ;
41055 int res2 = 0 ;
41056 PyObject * obj0 = 0 ;
41057 PyObject * obj1 = 0 ;
41058 char * kwnames[] = {
41059 (char *) "id",(char *) "parent", NULL
41060 };
41061
41062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41063 ecode1 = SWIG_AsVal_long(obj0, &val1);
41064 if (!SWIG_IsOK(ecode1)) {
41065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41066 }
41067 arg1 = static_cast< long >(val1);
41068 if (obj1) {
41069 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41070 if (!SWIG_IsOK(res2)) {
41071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41072 }
41073 arg2 = reinterpret_cast< wxWindow * >(argp2);
41074 }
41075 {
41076 if (!wxPyCheckForApp()) SWIG_fail;
41077 PyThreadState* __tstate = wxPyBeginAllowThreads();
41078 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41079 wxPyEndAllowThreads(__tstate);
41080 if (PyErr_Occurred()) SWIG_fail;
41081 }
41082 {
41083 resultobj = wxPyMake_wxObject(result, 0);
41084 }
41085 return resultobj;
41086 fail:
41087 return NULL;
41088 }
41089
41090
41091 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41092 PyObject *resultobj = 0;
41093 wxString *arg1 = 0 ;
41094 wxWindow *arg2 = (wxWindow *) NULL ;
41095 wxWindow *result = 0 ;
41096 bool temp1 = false ;
41097 void *argp2 = 0 ;
41098 int res2 = 0 ;
41099 PyObject * obj0 = 0 ;
41100 PyObject * obj1 = 0 ;
41101 char * kwnames[] = {
41102 (char *) "name",(char *) "parent", NULL
41103 };
41104
41105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41106 {
41107 arg1 = wxString_in_helper(obj0);
41108 if (arg1 == NULL) SWIG_fail;
41109 temp1 = true;
41110 }
41111 if (obj1) {
41112 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41113 if (!SWIG_IsOK(res2)) {
41114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41115 }
41116 arg2 = reinterpret_cast< wxWindow * >(argp2);
41117 }
41118 {
41119 if (!wxPyCheckForApp()) SWIG_fail;
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 {
41126 resultobj = wxPyMake_wxObject(result, 0);
41127 }
41128 {
41129 if (temp1)
41130 delete arg1;
41131 }
41132 return resultobj;
41133 fail:
41134 {
41135 if (temp1)
41136 delete arg1;
41137 }
41138 return NULL;
41139 }
41140
41141
41142 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41143 PyObject *resultobj = 0;
41144 wxString *arg1 = 0 ;
41145 wxWindow *arg2 = (wxWindow *) NULL ;
41146 wxWindow *result = 0 ;
41147 bool temp1 = false ;
41148 void *argp2 = 0 ;
41149 int res2 = 0 ;
41150 PyObject * obj0 = 0 ;
41151 PyObject * obj1 = 0 ;
41152 char * kwnames[] = {
41153 (char *) "label",(char *) "parent", NULL
41154 };
41155
41156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41157 {
41158 arg1 = wxString_in_helper(obj0);
41159 if (arg1 == NULL) SWIG_fail;
41160 temp1 = true;
41161 }
41162 if (obj1) {
41163 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41164 if (!SWIG_IsOK(res2)) {
41165 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41166 }
41167 arg2 = reinterpret_cast< wxWindow * >(argp2);
41168 }
41169 {
41170 if (!wxPyCheckForApp()) SWIG_fail;
41171 PyThreadState* __tstate = wxPyBeginAllowThreads();
41172 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41173 wxPyEndAllowThreads(__tstate);
41174 if (PyErr_Occurred()) SWIG_fail;
41175 }
41176 {
41177 resultobj = wxPyMake_wxObject(result, 0);
41178 }
41179 {
41180 if (temp1)
41181 delete arg1;
41182 }
41183 return resultobj;
41184 fail:
41185 {
41186 if (temp1)
41187 delete arg1;
41188 }
41189 return NULL;
41190 }
41191
41192
41193 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41194 PyObject *resultobj = 0;
41195 wxWindow *arg1 = (wxWindow *) 0 ;
41196 unsigned long arg2 ;
41197 wxWindow *result = 0 ;
41198 void *argp1 = 0 ;
41199 int res1 = 0 ;
41200 unsigned long val2 ;
41201 int ecode2 = 0 ;
41202 PyObject * obj0 = 0 ;
41203 PyObject * obj1 = 0 ;
41204 char * kwnames[] = {
41205 (char *) "parent",(char *) "_hWnd", NULL
41206 };
41207
41208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41210 if (!SWIG_IsOK(res1)) {
41211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41212 }
41213 arg1 = reinterpret_cast< wxWindow * >(argp1);
41214 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41215 if (!SWIG_IsOK(ecode2)) {
41216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41217 }
41218 arg2 = static_cast< unsigned long >(val2);
41219 {
41220 PyThreadState* __tstate = wxPyBeginAllowThreads();
41221 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41222 wxPyEndAllowThreads(__tstate);
41223 if (PyErr_Occurred()) SWIG_fail;
41224 }
41225 {
41226 resultobj = wxPyMake_wxObject(result, 0);
41227 }
41228 return resultobj;
41229 fail:
41230 return NULL;
41231 }
41232
41233
41234 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41235 PyObject *resultobj = 0;
41236 PyObject *result = 0 ;
41237
41238 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41239 {
41240 PyThreadState* __tstate = wxPyBeginAllowThreads();
41241 result = (PyObject *)GetTopLevelWindows();
41242 wxPyEndAllowThreads(__tstate);
41243 if (PyErr_Occurred()) SWIG_fail;
41244 }
41245 resultobj = result;
41246 return resultobj;
41247 fail:
41248 return NULL;
41249 }
41250
41251
41252 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41253 PyObject *resultobj = 0;
41254 wxValidator *result = 0 ;
41255
41256 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41257 {
41258 PyThreadState* __tstate = wxPyBeginAllowThreads();
41259 result = (wxValidator *)new wxValidator();
41260 wxPyEndAllowThreads(__tstate);
41261 if (PyErr_Occurred()) SWIG_fail;
41262 }
41263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41264 return resultobj;
41265 fail:
41266 return NULL;
41267 }
41268
41269
41270 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41271 PyObject *resultobj = 0;
41272 wxValidator *arg1 = (wxValidator *) 0 ;
41273 wxValidator *result = 0 ;
41274 void *argp1 = 0 ;
41275 int res1 = 0 ;
41276 PyObject *swig_obj[1] ;
41277
41278 if (!args) SWIG_fail;
41279 swig_obj[0] = args;
41280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41281 if (!SWIG_IsOK(res1)) {
41282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41283 }
41284 arg1 = reinterpret_cast< wxValidator * >(argp1);
41285 {
41286 PyThreadState* __tstate = wxPyBeginAllowThreads();
41287 result = (wxValidator *)(arg1)->Clone();
41288 wxPyEndAllowThreads(__tstate);
41289 if (PyErr_Occurred()) SWIG_fail;
41290 }
41291 {
41292 resultobj = wxPyMake_wxObject(result, 0);
41293 }
41294 return resultobj;
41295 fail:
41296 return NULL;
41297 }
41298
41299
41300 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41301 PyObject *resultobj = 0;
41302 wxValidator *arg1 = (wxValidator *) 0 ;
41303 wxWindow *arg2 = (wxWindow *) 0 ;
41304 bool result;
41305 void *argp1 = 0 ;
41306 int res1 = 0 ;
41307 void *argp2 = 0 ;
41308 int res2 = 0 ;
41309 PyObject * obj0 = 0 ;
41310 PyObject * obj1 = 0 ;
41311 char * kwnames[] = {
41312 (char *) "self",(char *) "parent", NULL
41313 };
41314
41315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41317 if (!SWIG_IsOK(res1)) {
41318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41319 }
41320 arg1 = reinterpret_cast< wxValidator * >(argp1);
41321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41322 if (!SWIG_IsOK(res2)) {
41323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41324 }
41325 arg2 = reinterpret_cast< wxWindow * >(argp2);
41326 {
41327 PyThreadState* __tstate = wxPyBeginAllowThreads();
41328 result = (bool)(arg1)->Validate(arg2);
41329 wxPyEndAllowThreads(__tstate);
41330 if (PyErr_Occurred()) SWIG_fail;
41331 }
41332 {
41333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41334 }
41335 return resultobj;
41336 fail:
41337 return NULL;
41338 }
41339
41340
41341 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41342 PyObject *resultobj = 0;
41343 wxValidator *arg1 = (wxValidator *) 0 ;
41344 bool result;
41345 void *argp1 = 0 ;
41346 int res1 = 0 ;
41347 PyObject *swig_obj[1] ;
41348
41349 if (!args) SWIG_fail;
41350 swig_obj[0] = args;
41351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41352 if (!SWIG_IsOK(res1)) {
41353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41354 }
41355 arg1 = reinterpret_cast< wxValidator * >(argp1);
41356 {
41357 PyThreadState* __tstate = wxPyBeginAllowThreads();
41358 result = (bool)(arg1)->TransferToWindow();
41359 wxPyEndAllowThreads(__tstate);
41360 if (PyErr_Occurred()) SWIG_fail;
41361 }
41362 {
41363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41364 }
41365 return resultobj;
41366 fail:
41367 return NULL;
41368 }
41369
41370
41371 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41372 PyObject *resultobj = 0;
41373 wxValidator *arg1 = (wxValidator *) 0 ;
41374 bool result;
41375 void *argp1 = 0 ;
41376 int res1 = 0 ;
41377 PyObject *swig_obj[1] ;
41378
41379 if (!args) SWIG_fail;
41380 swig_obj[0] = args;
41381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41382 if (!SWIG_IsOK(res1)) {
41383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41384 }
41385 arg1 = reinterpret_cast< wxValidator * >(argp1);
41386 {
41387 PyThreadState* __tstate = wxPyBeginAllowThreads();
41388 result = (bool)(arg1)->TransferFromWindow();
41389 wxPyEndAllowThreads(__tstate);
41390 if (PyErr_Occurred()) SWIG_fail;
41391 }
41392 {
41393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41394 }
41395 return resultobj;
41396 fail:
41397 return NULL;
41398 }
41399
41400
41401 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41402 PyObject *resultobj = 0;
41403 wxValidator *arg1 = (wxValidator *) 0 ;
41404 wxWindow *result = 0 ;
41405 void *argp1 = 0 ;
41406 int res1 = 0 ;
41407 PyObject *swig_obj[1] ;
41408
41409 if (!args) SWIG_fail;
41410 swig_obj[0] = args;
41411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41412 if (!SWIG_IsOK(res1)) {
41413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41414 }
41415 arg1 = reinterpret_cast< wxValidator * >(argp1);
41416 {
41417 PyThreadState* __tstate = wxPyBeginAllowThreads();
41418 result = (wxWindow *)(arg1)->GetWindow();
41419 wxPyEndAllowThreads(__tstate);
41420 if (PyErr_Occurred()) SWIG_fail;
41421 }
41422 {
41423 resultobj = wxPyMake_wxObject(result, 0);
41424 }
41425 return resultobj;
41426 fail:
41427 return NULL;
41428 }
41429
41430
41431 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41432 PyObject *resultobj = 0;
41433 wxValidator *arg1 = (wxValidator *) 0 ;
41434 wxWindow *arg2 = (wxWindow *) 0 ;
41435 void *argp1 = 0 ;
41436 int res1 = 0 ;
41437 void *argp2 = 0 ;
41438 int res2 = 0 ;
41439 PyObject * obj0 = 0 ;
41440 PyObject * obj1 = 0 ;
41441 char * kwnames[] = {
41442 (char *) "self",(char *) "window", NULL
41443 };
41444
41445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41447 if (!SWIG_IsOK(res1)) {
41448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41449 }
41450 arg1 = reinterpret_cast< wxValidator * >(argp1);
41451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41452 if (!SWIG_IsOK(res2)) {
41453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41454 }
41455 arg2 = reinterpret_cast< wxWindow * >(argp2);
41456 {
41457 PyThreadState* __tstate = wxPyBeginAllowThreads();
41458 (arg1)->SetWindow(arg2);
41459 wxPyEndAllowThreads(__tstate);
41460 if (PyErr_Occurred()) SWIG_fail;
41461 }
41462 resultobj = SWIG_Py_Void();
41463 return resultobj;
41464 fail:
41465 return NULL;
41466 }
41467
41468
41469 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41470 PyObject *resultobj = 0;
41471 bool result;
41472
41473 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41474 {
41475 PyThreadState* __tstate = wxPyBeginAllowThreads();
41476 result = (bool)wxValidator::IsSilent();
41477 wxPyEndAllowThreads(__tstate);
41478 if (PyErr_Occurred()) SWIG_fail;
41479 }
41480 {
41481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41482 }
41483 return resultobj;
41484 fail:
41485 return NULL;
41486 }
41487
41488
41489 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41490 PyObject *resultobj = 0;
41491 int arg1 = (int) true ;
41492 int val1 ;
41493 int ecode1 = 0 ;
41494 PyObject * obj0 = 0 ;
41495 char * kwnames[] = {
41496 (char *) "doIt", NULL
41497 };
41498
41499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41500 if (obj0) {
41501 ecode1 = SWIG_AsVal_int(obj0, &val1);
41502 if (!SWIG_IsOK(ecode1)) {
41503 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41504 }
41505 arg1 = static_cast< int >(val1);
41506 }
41507 {
41508 PyThreadState* __tstate = wxPyBeginAllowThreads();
41509 wxValidator::SetBellOnError(arg1);
41510 wxPyEndAllowThreads(__tstate);
41511 if (PyErr_Occurred()) SWIG_fail;
41512 }
41513 resultobj = SWIG_Py_Void();
41514 return resultobj;
41515 fail:
41516 return NULL;
41517 }
41518
41519
41520 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41521 PyObject *obj;
41522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41523 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41524 return SWIG_Py_Void();
41525 }
41526
41527 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41528 return SWIG_Python_InitShadowInstance(args);
41529 }
41530
41531 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41532 PyObject *resultobj = 0;
41533 wxPyValidator *result = 0 ;
41534
41535 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41536 {
41537 PyThreadState* __tstate = wxPyBeginAllowThreads();
41538 result = (wxPyValidator *)new wxPyValidator();
41539 wxPyEndAllowThreads(__tstate);
41540 if (PyErr_Occurred()) SWIG_fail;
41541 }
41542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41543 return resultobj;
41544 fail:
41545 return NULL;
41546 }
41547
41548
41549 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41550 PyObject *resultobj = 0;
41551 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41552 PyObject *arg2 = (PyObject *) 0 ;
41553 PyObject *arg3 = (PyObject *) 0 ;
41554 int arg4 = (int) 1 ;
41555 void *argp1 = 0 ;
41556 int res1 = 0 ;
41557 int val4 ;
41558 int ecode4 = 0 ;
41559 PyObject * obj0 = 0 ;
41560 PyObject * obj1 = 0 ;
41561 PyObject * obj2 = 0 ;
41562 PyObject * obj3 = 0 ;
41563 char * kwnames[] = {
41564 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41565 };
41566
41567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41569 if (!SWIG_IsOK(res1)) {
41570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41571 }
41572 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41573 arg2 = obj1;
41574 arg3 = obj2;
41575 if (obj3) {
41576 ecode4 = SWIG_AsVal_int(obj3, &val4);
41577 if (!SWIG_IsOK(ecode4)) {
41578 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41579 }
41580 arg4 = static_cast< int >(val4);
41581 }
41582 {
41583 PyThreadState* __tstate = wxPyBeginAllowThreads();
41584 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41585 wxPyEndAllowThreads(__tstate);
41586 if (PyErr_Occurred()) SWIG_fail;
41587 }
41588 resultobj = SWIG_Py_Void();
41589 return resultobj;
41590 fail:
41591 return NULL;
41592 }
41593
41594
41595 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41596 PyObject *obj;
41597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41598 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41599 return SWIG_Py_Void();
41600 }
41601
41602 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41603 return SWIG_Python_InitShadowInstance(args);
41604 }
41605
41606 SWIGINTERN int DefaultValidator_set(PyObject *) {
41607 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41608 return 1;
41609 }
41610
41611
41612 SWIGINTERN PyObject *DefaultValidator_get(void) {
41613 PyObject *pyobj = 0;
41614
41615 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41616 return pyobj;
41617 }
41618
41619
41620 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41621 PyObject *resultobj = 0;
41622 wxString const &arg1_defvalue = wxPyEmptyString ;
41623 wxString *arg1 = (wxString *) &arg1_defvalue ;
41624 long arg2 = (long) 0 ;
41625 wxMenu *result = 0 ;
41626 bool temp1 = false ;
41627 long val2 ;
41628 int ecode2 = 0 ;
41629 PyObject * obj0 = 0 ;
41630 PyObject * obj1 = 0 ;
41631 char * kwnames[] = {
41632 (char *) "title",(char *) "style", NULL
41633 };
41634
41635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41636 if (obj0) {
41637 {
41638 arg1 = wxString_in_helper(obj0);
41639 if (arg1 == NULL) SWIG_fail;
41640 temp1 = true;
41641 }
41642 }
41643 if (obj1) {
41644 ecode2 = SWIG_AsVal_long(obj1, &val2);
41645 if (!SWIG_IsOK(ecode2)) {
41646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41647 }
41648 arg2 = static_cast< long >(val2);
41649 }
41650 {
41651 if (!wxPyCheckForApp()) SWIG_fail;
41652 PyThreadState* __tstate = wxPyBeginAllowThreads();
41653 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41654 wxPyEndAllowThreads(__tstate);
41655 if (PyErr_Occurred()) SWIG_fail;
41656 }
41657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41658 {
41659 if (temp1)
41660 delete arg1;
41661 }
41662 return resultobj;
41663 fail:
41664 {
41665 if (temp1)
41666 delete arg1;
41667 }
41668 return NULL;
41669 }
41670
41671
41672 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41673 PyObject *resultobj = 0;
41674 wxMenu *arg1 = (wxMenu *) 0 ;
41675 int arg2 ;
41676 wxString const &arg3_defvalue = wxPyEmptyString ;
41677 wxString *arg3 = (wxString *) &arg3_defvalue ;
41678 wxString const &arg4_defvalue = wxPyEmptyString ;
41679 wxString *arg4 = (wxString *) &arg4_defvalue ;
41680 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41681 wxMenuItem *result = 0 ;
41682 void *argp1 = 0 ;
41683 int res1 = 0 ;
41684 int val2 ;
41685 int ecode2 = 0 ;
41686 bool temp3 = false ;
41687 bool temp4 = false ;
41688 int val5 ;
41689 int ecode5 = 0 ;
41690 PyObject * obj0 = 0 ;
41691 PyObject * obj1 = 0 ;
41692 PyObject * obj2 = 0 ;
41693 PyObject * obj3 = 0 ;
41694 PyObject * obj4 = 0 ;
41695 char * kwnames[] = {
41696 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41697 };
41698
41699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41701 if (!SWIG_IsOK(res1)) {
41702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41703 }
41704 arg1 = reinterpret_cast< wxMenu * >(argp1);
41705 ecode2 = SWIG_AsVal_int(obj1, &val2);
41706 if (!SWIG_IsOK(ecode2)) {
41707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41708 }
41709 arg2 = static_cast< int >(val2);
41710 if (obj2) {
41711 {
41712 arg3 = wxString_in_helper(obj2);
41713 if (arg3 == NULL) SWIG_fail;
41714 temp3 = true;
41715 }
41716 }
41717 if (obj3) {
41718 {
41719 arg4 = wxString_in_helper(obj3);
41720 if (arg4 == NULL) SWIG_fail;
41721 temp4 = true;
41722 }
41723 }
41724 if (obj4) {
41725 ecode5 = SWIG_AsVal_int(obj4, &val5);
41726 if (!SWIG_IsOK(ecode5)) {
41727 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41728 }
41729 arg5 = static_cast< wxItemKind >(val5);
41730 }
41731 {
41732 PyThreadState* __tstate = wxPyBeginAllowThreads();
41733 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41734 wxPyEndAllowThreads(__tstate);
41735 if (PyErr_Occurred()) SWIG_fail;
41736 }
41737 {
41738 resultobj = wxPyMake_wxObject(result, (bool)0);
41739 }
41740 {
41741 if (temp3)
41742 delete arg3;
41743 }
41744 {
41745 if (temp4)
41746 delete arg4;
41747 }
41748 return resultobj;
41749 fail:
41750 {
41751 if (temp3)
41752 delete arg3;
41753 }
41754 {
41755 if (temp4)
41756 delete arg4;
41757 }
41758 return NULL;
41759 }
41760
41761
41762 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41763 PyObject *resultobj = 0;
41764 wxMenu *arg1 = (wxMenu *) 0 ;
41765 wxMenuItem *result = 0 ;
41766 void *argp1 = 0 ;
41767 int res1 = 0 ;
41768 PyObject *swig_obj[1] ;
41769
41770 if (!args) SWIG_fail;
41771 swig_obj[0] = args;
41772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41773 if (!SWIG_IsOK(res1)) {
41774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41775 }
41776 arg1 = reinterpret_cast< wxMenu * >(argp1);
41777 {
41778 PyThreadState* __tstate = wxPyBeginAllowThreads();
41779 result = (wxMenuItem *)(arg1)->AppendSeparator();
41780 wxPyEndAllowThreads(__tstate);
41781 if (PyErr_Occurred()) SWIG_fail;
41782 }
41783 {
41784 resultobj = wxPyMake_wxObject(result, (bool)0);
41785 }
41786 return resultobj;
41787 fail:
41788 return NULL;
41789 }
41790
41791
41792 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41793 PyObject *resultobj = 0;
41794 wxMenu *arg1 = (wxMenu *) 0 ;
41795 int arg2 ;
41796 wxString *arg3 = 0 ;
41797 wxString const &arg4_defvalue = wxPyEmptyString ;
41798 wxString *arg4 = (wxString *) &arg4_defvalue ;
41799 wxMenuItem *result = 0 ;
41800 void *argp1 = 0 ;
41801 int res1 = 0 ;
41802 int val2 ;
41803 int ecode2 = 0 ;
41804 bool temp3 = false ;
41805 bool temp4 = false ;
41806 PyObject * obj0 = 0 ;
41807 PyObject * obj1 = 0 ;
41808 PyObject * obj2 = 0 ;
41809 PyObject * obj3 = 0 ;
41810 char * kwnames[] = {
41811 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41812 };
41813
41814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41816 if (!SWIG_IsOK(res1)) {
41817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41818 }
41819 arg1 = reinterpret_cast< wxMenu * >(argp1);
41820 ecode2 = SWIG_AsVal_int(obj1, &val2);
41821 if (!SWIG_IsOK(ecode2)) {
41822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41823 }
41824 arg2 = static_cast< int >(val2);
41825 {
41826 arg3 = wxString_in_helper(obj2);
41827 if (arg3 == NULL) SWIG_fail;
41828 temp3 = true;
41829 }
41830 if (obj3) {
41831 {
41832 arg4 = wxString_in_helper(obj3);
41833 if (arg4 == NULL) SWIG_fail;
41834 temp4 = true;
41835 }
41836 }
41837 {
41838 PyThreadState* __tstate = wxPyBeginAllowThreads();
41839 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41840 wxPyEndAllowThreads(__tstate);
41841 if (PyErr_Occurred()) SWIG_fail;
41842 }
41843 {
41844 resultobj = wxPyMake_wxObject(result, (bool)0);
41845 }
41846 {
41847 if (temp3)
41848 delete arg3;
41849 }
41850 {
41851 if (temp4)
41852 delete arg4;
41853 }
41854 return resultobj;
41855 fail:
41856 {
41857 if (temp3)
41858 delete arg3;
41859 }
41860 {
41861 if (temp4)
41862 delete arg4;
41863 }
41864 return NULL;
41865 }
41866
41867
41868 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41869 PyObject *resultobj = 0;
41870 wxMenu *arg1 = (wxMenu *) 0 ;
41871 int arg2 ;
41872 wxString *arg3 = 0 ;
41873 wxString const &arg4_defvalue = wxPyEmptyString ;
41874 wxString *arg4 = (wxString *) &arg4_defvalue ;
41875 wxMenuItem *result = 0 ;
41876 void *argp1 = 0 ;
41877 int res1 = 0 ;
41878 int val2 ;
41879 int ecode2 = 0 ;
41880 bool temp3 = false ;
41881 bool temp4 = false ;
41882 PyObject * obj0 = 0 ;
41883 PyObject * obj1 = 0 ;
41884 PyObject * obj2 = 0 ;
41885 PyObject * obj3 = 0 ;
41886 char * kwnames[] = {
41887 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41888 };
41889
41890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41892 if (!SWIG_IsOK(res1)) {
41893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41894 }
41895 arg1 = reinterpret_cast< wxMenu * >(argp1);
41896 ecode2 = SWIG_AsVal_int(obj1, &val2);
41897 if (!SWIG_IsOK(ecode2)) {
41898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41899 }
41900 arg2 = static_cast< int >(val2);
41901 {
41902 arg3 = wxString_in_helper(obj2);
41903 if (arg3 == NULL) SWIG_fail;
41904 temp3 = true;
41905 }
41906 if (obj3) {
41907 {
41908 arg4 = wxString_in_helper(obj3);
41909 if (arg4 == NULL) SWIG_fail;
41910 temp4 = true;
41911 }
41912 }
41913 {
41914 PyThreadState* __tstate = wxPyBeginAllowThreads();
41915 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41916 wxPyEndAllowThreads(__tstate);
41917 if (PyErr_Occurred()) SWIG_fail;
41918 }
41919 {
41920 resultobj = wxPyMake_wxObject(result, (bool)0);
41921 }
41922 {
41923 if (temp3)
41924 delete arg3;
41925 }
41926 {
41927 if (temp4)
41928 delete arg4;
41929 }
41930 return resultobj;
41931 fail:
41932 {
41933 if (temp3)
41934 delete arg3;
41935 }
41936 {
41937 if (temp4)
41938 delete arg4;
41939 }
41940 return NULL;
41941 }
41942
41943
41944 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41945 PyObject *resultobj = 0;
41946 wxMenu *arg1 = (wxMenu *) 0 ;
41947 int arg2 ;
41948 wxString *arg3 = 0 ;
41949 wxMenu *arg4 = (wxMenu *) 0 ;
41950 wxString const &arg5_defvalue = wxPyEmptyString ;
41951 wxString *arg5 = (wxString *) &arg5_defvalue ;
41952 wxMenuItem *result = 0 ;
41953 void *argp1 = 0 ;
41954 int res1 = 0 ;
41955 int val2 ;
41956 int ecode2 = 0 ;
41957 bool temp3 = false ;
41958 void *argp4 = 0 ;
41959 int res4 = 0 ;
41960 bool temp5 = false ;
41961 PyObject * obj0 = 0 ;
41962 PyObject * obj1 = 0 ;
41963 PyObject * obj2 = 0 ;
41964 PyObject * obj3 = 0 ;
41965 PyObject * obj4 = 0 ;
41966 char * kwnames[] = {
41967 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
41968 };
41969
41970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41972 if (!SWIG_IsOK(res1)) {
41973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
41974 }
41975 arg1 = reinterpret_cast< wxMenu * >(argp1);
41976 ecode2 = SWIG_AsVal_int(obj1, &val2);
41977 if (!SWIG_IsOK(ecode2)) {
41978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
41979 }
41980 arg2 = static_cast< int >(val2);
41981 {
41982 arg3 = wxString_in_helper(obj2);
41983 if (arg3 == NULL) SWIG_fail;
41984 temp3 = true;
41985 }
41986 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
41987 if (!SWIG_IsOK(res4)) {
41988 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
41989 }
41990 arg4 = reinterpret_cast< wxMenu * >(argp4);
41991 if (obj4) {
41992 {
41993 arg5 = wxString_in_helper(obj4);
41994 if (arg5 == NULL) SWIG_fail;
41995 temp5 = true;
41996 }
41997 }
41998 {
41999 PyThreadState* __tstate = wxPyBeginAllowThreads();
42000 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42001 wxPyEndAllowThreads(__tstate);
42002 if (PyErr_Occurred()) SWIG_fail;
42003 }
42004 {
42005 resultobj = wxPyMake_wxObject(result, (bool)0);
42006 }
42007 {
42008 if (temp3)
42009 delete arg3;
42010 }
42011 {
42012 if (temp5)
42013 delete arg5;
42014 }
42015 return resultobj;
42016 fail:
42017 {
42018 if (temp3)
42019 delete arg3;
42020 }
42021 {
42022 if (temp5)
42023 delete arg5;
42024 }
42025 return NULL;
42026 }
42027
42028
42029 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42030 PyObject *resultobj = 0;
42031 wxMenu *arg1 = (wxMenu *) 0 ;
42032 wxMenu *arg2 = (wxMenu *) 0 ;
42033 wxString *arg3 = 0 ;
42034 wxString const &arg4_defvalue = wxPyEmptyString ;
42035 wxString *arg4 = (wxString *) &arg4_defvalue ;
42036 wxMenuItem *result = 0 ;
42037 void *argp1 = 0 ;
42038 int res1 = 0 ;
42039 void *argp2 = 0 ;
42040 int res2 = 0 ;
42041 bool temp3 = false ;
42042 bool temp4 = false ;
42043 PyObject * obj0 = 0 ;
42044 PyObject * obj1 = 0 ;
42045 PyObject * obj2 = 0 ;
42046 PyObject * obj3 = 0 ;
42047 char * kwnames[] = {
42048 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42049 };
42050
42051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42055 }
42056 arg1 = reinterpret_cast< wxMenu * >(argp1);
42057 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42058 if (!SWIG_IsOK(res2)) {
42059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42060 }
42061 arg2 = reinterpret_cast< wxMenu * >(argp2);
42062 {
42063 arg3 = wxString_in_helper(obj2);
42064 if (arg3 == NULL) SWIG_fail;
42065 temp3 = true;
42066 }
42067 if (obj3) {
42068 {
42069 arg4 = wxString_in_helper(obj3);
42070 if (arg4 == NULL) SWIG_fail;
42071 temp4 = true;
42072 }
42073 }
42074 {
42075 PyThreadState* __tstate = wxPyBeginAllowThreads();
42076 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42077 wxPyEndAllowThreads(__tstate);
42078 if (PyErr_Occurred()) SWIG_fail;
42079 }
42080 {
42081 resultobj = wxPyMake_wxObject(result, (bool)0);
42082 }
42083 {
42084 if (temp3)
42085 delete arg3;
42086 }
42087 {
42088 if (temp4)
42089 delete arg4;
42090 }
42091 return resultobj;
42092 fail:
42093 {
42094 if (temp3)
42095 delete arg3;
42096 }
42097 {
42098 if (temp4)
42099 delete arg4;
42100 }
42101 return NULL;
42102 }
42103
42104
42105 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42106 PyObject *resultobj = 0;
42107 wxMenu *arg1 = (wxMenu *) 0 ;
42108 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42109 wxMenuItem *result = 0 ;
42110 void *argp1 = 0 ;
42111 int res1 = 0 ;
42112 int res2 = 0 ;
42113 PyObject * obj0 = 0 ;
42114 PyObject * obj1 = 0 ;
42115 char * kwnames[] = {
42116 (char *) "self",(char *) "item", NULL
42117 };
42118
42119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42121 if (!SWIG_IsOK(res1)) {
42122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42123 }
42124 arg1 = reinterpret_cast< wxMenu * >(argp1);
42125 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42126 if (!SWIG_IsOK(res2)) {
42127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42128 }
42129 {
42130 PyThreadState* __tstate = wxPyBeginAllowThreads();
42131 result = (wxMenuItem *)(arg1)->Append(arg2);
42132 wxPyEndAllowThreads(__tstate);
42133 if (PyErr_Occurred()) SWIG_fail;
42134 }
42135 {
42136 resultobj = wxPyMake_wxObject(result, (bool)0);
42137 }
42138 return resultobj;
42139 fail:
42140 return NULL;
42141 }
42142
42143
42144 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42145 PyObject *resultobj = 0;
42146 wxMenu *arg1 = (wxMenu *) 0 ;
42147 size_t arg2 ;
42148 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42149 wxMenuItem *result = 0 ;
42150 void *argp1 = 0 ;
42151 int res1 = 0 ;
42152 size_t val2 ;
42153 int ecode2 = 0 ;
42154 int res3 = 0 ;
42155 PyObject * obj0 = 0 ;
42156 PyObject * obj1 = 0 ;
42157 PyObject * obj2 = 0 ;
42158 char * kwnames[] = {
42159 (char *) "self",(char *) "pos",(char *) "item", NULL
42160 };
42161
42162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42164 if (!SWIG_IsOK(res1)) {
42165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42166 }
42167 arg1 = reinterpret_cast< wxMenu * >(argp1);
42168 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42169 if (!SWIG_IsOK(ecode2)) {
42170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42171 }
42172 arg2 = static_cast< size_t >(val2);
42173 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42174 if (!SWIG_IsOK(res3)) {
42175 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42176 }
42177 {
42178 PyThreadState* __tstate = wxPyBeginAllowThreads();
42179 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42180 wxPyEndAllowThreads(__tstate);
42181 if (PyErr_Occurred()) SWIG_fail;
42182 }
42183 {
42184 resultobj = wxPyMake_wxObject(result, (bool)0);
42185 }
42186 return resultobj;
42187 fail:
42188 return NULL;
42189 }
42190
42191
42192 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42193 PyObject *resultobj = 0;
42194 wxMenu *arg1 = (wxMenu *) 0 ;
42195 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42196 wxMenuItem *result = 0 ;
42197 void *argp1 = 0 ;
42198 int res1 = 0 ;
42199 int res2 = 0 ;
42200 PyObject * obj0 = 0 ;
42201 PyObject * obj1 = 0 ;
42202 char * kwnames[] = {
42203 (char *) "self",(char *) "item", NULL
42204 };
42205
42206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42208 if (!SWIG_IsOK(res1)) {
42209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42210 }
42211 arg1 = reinterpret_cast< wxMenu * >(argp1);
42212 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42213 if (!SWIG_IsOK(res2)) {
42214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42215 }
42216 {
42217 PyThreadState* __tstate = wxPyBeginAllowThreads();
42218 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42219 wxPyEndAllowThreads(__tstate);
42220 if (PyErr_Occurred()) SWIG_fail;
42221 }
42222 {
42223 resultobj = wxPyMake_wxObject(result, (bool)0);
42224 }
42225 return resultobj;
42226 fail:
42227 return NULL;
42228 }
42229
42230
42231 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42232 PyObject *resultobj = 0;
42233 wxMenu *arg1 = (wxMenu *) 0 ;
42234 void *argp1 = 0 ;
42235 int res1 = 0 ;
42236 PyObject *swig_obj[1] ;
42237
42238 if (!args) SWIG_fail;
42239 swig_obj[0] = args;
42240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42241 if (!SWIG_IsOK(res1)) {
42242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42243 }
42244 arg1 = reinterpret_cast< wxMenu * >(argp1);
42245 {
42246 PyThreadState* __tstate = wxPyBeginAllowThreads();
42247 (arg1)->Break();
42248 wxPyEndAllowThreads(__tstate);
42249 if (PyErr_Occurred()) SWIG_fail;
42250 }
42251 resultobj = SWIG_Py_Void();
42252 return resultobj;
42253 fail:
42254 return NULL;
42255 }
42256
42257
42258 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42259 PyObject *resultobj = 0;
42260 wxMenu *arg1 = (wxMenu *) 0 ;
42261 size_t arg2 ;
42262 int arg3 ;
42263 wxString const &arg4_defvalue = wxPyEmptyString ;
42264 wxString *arg4 = (wxString *) &arg4_defvalue ;
42265 wxString const &arg5_defvalue = wxPyEmptyString ;
42266 wxString *arg5 = (wxString *) &arg5_defvalue ;
42267 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42268 wxMenuItem *result = 0 ;
42269 void *argp1 = 0 ;
42270 int res1 = 0 ;
42271 size_t val2 ;
42272 int ecode2 = 0 ;
42273 int val3 ;
42274 int ecode3 = 0 ;
42275 bool temp4 = false ;
42276 bool temp5 = false ;
42277 int val6 ;
42278 int ecode6 = 0 ;
42279 PyObject * obj0 = 0 ;
42280 PyObject * obj1 = 0 ;
42281 PyObject * obj2 = 0 ;
42282 PyObject * obj3 = 0 ;
42283 PyObject * obj4 = 0 ;
42284 PyObject * obj5 = 0 ;
42285 char * kwnames[] = {
42286 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42287 };
42288
42289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42291 if (!SWIG_IsOK(res1)) {
42292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42293 }
42294 arg1 = reinterpret_cast< wxMenu * >(argp1);
42295 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42296 if (!SWIG_IsOK(ecode2)) {
42297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42298 }
42299 arg2 = static_cast< size_t >(val2);
42300 ecode3 = SWIG_AsVal_int(obj2, &val3);
42301 if (!SWIG_IsOK(ecode3)) {
42302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42303 }
42304 arg3 = static_cast< int >(val3);
42305 if (obj3) {
42306 {
42307 arg4 = wxString_in_helper(obj3);
42308 if (arg4 == NULL) SWIG_fail;
42309 temp4 = true;
42310 }
42311 }
42312 if (obj4) {
42313 {
42314 arg5 = wxString_in_helper(obj4);
42315 if (arg5 == NULL) SWIG_fail;
42316 temp5 = true;
42317 }
42318 }
42319 if (obj5) {
42320 ecode6 = SWIG_AsVal_int(obj5, &val6);
42321 if (!SWIG_IsOK(ecode6)) {
42322 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42323 }
42324 arg6 = static_cast< wxItemKind >(val6);
42325 }
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42329 wxPyEndAllowThreads(__tstate);
42330 if (PyErr_Occurred()) SWIG_fail;
42331 }
42332 {
42333 resultobj = wxPyMake_wxObject(result, (bool)0);
42334 }
42335 {
42336 if (temp4)
42337 delete arg4;
42338 }
42339 {
42340 if (temp5)
42341 delete arg5;
42342 }
42343 return resultobj;
42344 fail:
42345 {
42346 if (temp4)
42347 delete arg4;
42348 }
42349 {
42350 if (temp5)
42351 delete arg5;
42352 }
42353 return NULL;
42354 }
42355
42356
42357 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42358 PyObject *resultobj = 0;
42359 wxMenu *arg1 = (wxMenu *) 0 ;
42360 size_t arg2 ;
42361 wxMenuItem *result = 0 ;
42362 void *argp1 = 0 ;
42363 int res1 = 0 ;
42364 size_t val2 ;
42365 int ecode2 = 0 ;
42366 PyObject * obj0 = 0 ;
42367 PyObject * obj1 = 0 ;
42368 char * kwnames[] = {
42369 (char *) "self",(char *) "pos", NULL
42370 };
42371
42372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42374 if (!SWIG_IsOK(res1)) {
42375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42376 }
42377 arg1 = reinterpret_cast< wxMenu * >(argp1);
42378 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42379 if (!SWIG_IsOK(ecode2)) {
42380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42381 }
42382 arg2 = static_cast< size_t >(val2);
42383 {
42384 PyThreadState* __tstate = wxPyBeginAllowThreads();
42385 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42386 wxPyEndAllowThreads(__tstate);
42387 if (PyErr_Occurred()) SWIG_fail;
42388 }
42389 {
42390 resultobj = wxPyMake_wxObject(result, (bool)0);
42391 }
42392 return resultobj;
42393 fail:
42394 return NULL;
42395 }
42396
42397
42398 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42399 PyObject *resultobj = 0;
42400 wxMenu *arg1 = (wxMenu *) 0 ;
42401 size_t arg2 ;
42402 int arg3 ;
42403 wxString *arg4 = 0 ;
42404 wxString const &arg5_defvalue = wxPyEmptyString ;
42405 wxString *arg5 = (wxString *) &arg5_defvalue ;
42406 wxMenuItem *result = 0 ;
42407 void *argp1 = 0 ;
42408 int res1 = 0 ;
42409 size_t val2 ;
42410 int ecode2 = 0 ;
42411 int val3 ;
42412 int ecode3 = 0 ;
42413 bool temp4 = false ;
42414 bool temp5 = false ;
42415 PyObject * obj0 = 0 ;
42416 PyObject * obj1 = 0 ;
42417 PyObject * obj2 = 0 ;
42418 PyObject * obj3 = 0 ;
42419 PyObject * obj4 = 0 ;
42420 char * kwnames[] = {
42421 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42422 };
42423
42424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42426 if (!SWIG_IsOK(res1)) {
42427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42428 }
42429 arg1 = reinterpret_cast< wxMenu * >(argp1);
42430 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42431 if (!SWIG_IsOK(ecode2)) {
42432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42433 }
42434 arg2 = static_cast< size_t >(val2);
42435 ecode3 = SWIG_AsVal_int(obj2, &val3);
42436 if (!SWIG_IsOK(ecode3)) {
42437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42438 }
42439 arg3 = static_cast< int >(val3);
42440 {
42441 arg4 = wxString_in_helper(obj3);
42442 if (arg4 == NULL) SWIG_fail;
42443 temp4 = true;
42444 }
42445 if (obj4) {
42446 {
42447 arg5 = wxString_in_helper(obj4);
42448 if (arg5 == NULL) SWIG_fail;
42449 temp5 = true;
42450 }
42451 }
42452 {
42453 PyThreadState* __tstate = wxPyBeginAllowThreads();
42454 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42455 wxPyEndAllowThreads(__tstate);
42456 if (PyErr_Occurred()) SWIG_fail;
42457 }
42458 {
42459 resultobj = wxPyMake_wxObject(result, (bool)0);
42460 }
42461 {
42462 if (temp4)
42463 delete arg4;
42464 }
42465 {
42466 if (temp5)
42467 delete arg5;
42468 }
42469 return resultobj;
42470 fail:
42471 {
42472 if (temp4)
42473 delete arg4;
42474 }
42475 {
42476 if (temp5)
42477 delete arg5;
42478 }
42479 return NULL;
42480 }
42481
42482
42483 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42484 PyObject *resultobj = 0;
42485 wxMenu *arg1 = (wxMenu *) 0 ;
42486 size_t arg2 ;
42487 int arg3 ;
42488 wxString *arg4 = 0 ;
42489 wxString const &arg5_defvalue = wxPyEmptyString ;
42490 wxString *arg5 = (wxString *) &arg5_defvalue ;
42491 wxMenuItem *result = 0 ;
42492 void *argp1 = 0 ;
42493 int res1 = 0 ;
42494 size_t val2 ;
42495 int ecode2 = 0 ;
42496 int val3 ;
42497 int ecode3 = 0 ;
42498 bool temp4 = false ;
42499 bool temp5 = false ;
42500 PyObject * obj0 = 0 ;
42501 PyObject * obj1 = 0 ;
42502 PyObject * obj2 = 0 ;
42503 PyObject * obj3 = 0 ;
42504 PyObject * obj4 = 0 ;
42505 char * kwnames[] = {
42506 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42507 };
42508
42509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42511 if (!SWIG_IsOK(res1)) {
42512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42513 }
42514 arg1 = reinterpret_cast< wxMenu * >(argp1);
42515 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42516 if (!SWIG_IsOK(ecode2)) {
42517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42518 }
42519 arg2 = static_cast< size_t >(val2);
42520 ecode3 = SWIG_AsVal_int(obj2, &val3);
42521 if (!SWIG_IsOK(ecode3)) {
42522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42523 }
42524 arg3 = static_cast< int >(val3);
42525 {
42526 arg4 = wxString_in_helper(obj3);
42527 if (arg4 == NULL) SWIG_fail;
42528 temp4 = true;
42529 }
42530 if (obj4) {
42531 {
42532 arg5 = wxString_in_helper(obj4);
42533 if (arg5 == NULL) SWIG_fail;
42534 temp5 = true;
42535 }
42536 }
42537 {
42538 PyThreadState* __tstate = wxPyBeginAllowThreads();
42539 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42540 wxPyEndAllowThreads(__tstate);
42541 if (PyErr_Occurred()) SWIG_fail;
42542 }
42543 {
42544 resultobj = wxPyMake_wxObject(result, (bool)0);
42545 }
42546 {
42547 if (temp4)
42548 delete arg4;
42549 }
42550 {
42551 if (temp5)
42552 delete arg5;
42553 }
42554 return resultobj;
42555 fail:
42556 {
42557 if (temp4)
42558 delete arg4;
42559 }
42560 {
42561 if (temp5)
42562 delete arg5;
42563 }
42564 return NULL;
42565 }
42566
42567
42568 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42569 PyObject *resultobj = 0;
42570 wxMenu *arg1 = (wxMenu *) 0 ;
42571 size_t arg2 ;
42572 int arg3 ;
42573 wxString *arg4 = 0 ;
42574 wxMenu *arg5 = (wxMenu *) 0 ;
42575 wxString const &arg6_defvalue = wxPyEmptyString ;
42576 wxString *arg6 = (wxString *) &arg6_defvalue ;
42577 wxMenuItem *result = 0 ;
42578 void *argp1 = 0 ;
42579 int res1 = 0 ;
42580 size_t val2 ;
42581 int ecode2 = 0 ;
42582 int val3 ;
42583 int ecode3 = 0 ;
42584 bool temp4 = false ;
42585 void *argp5 = 0 ;
42586 int res5 = 0 ;
42587 bool temp6 = false ;
42588 PyObject * obj0 = 0 ;
42589 PyObject * obj1 = 0 ;
42590 PyObject * obj2 = 0 ;
42591 PyObject * obj3 = 0 ;
42592 PyObject * obj4 = 0 ;
42593 PyObject * obj5 = 0 ;
42594 char * kwnames[] = {
42595 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42596 };
42597
42598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42600 if (!SWIG_IsOK(res1)) {
42601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42602 }
42603 arg1 = reinterpret_cast< wxMenu * >(argp1);
42604 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42605 if (!SWIG_IsOK(ecode2)) {
42606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42607 }
42608 arg2 = static_cast< size_t >(val2);
42609 ecode3 = SWIG_AsVal_int(obj2, &val3);
42610 if (!SWIG_IsOK(ecode3)) {
42611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42612 }
42613 arg3 = static_cast< int >(val3);
42614 {
42615 arg4 = wxString_in_helper(obj3);
42616 if (arg4 == NULL) SWIG_fail;
42617 temp4 = true;
42618 }
42619 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42620 if (!SWIG_IsOK(res5)) {
42621 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42622 }
42623 arg5 = reinterpret_cast< wxMenu * >(argp5);
42624 if (obj5) {
42625 {
42626 arg6 = wxString_in_helper(obj5);
42627 if (arg6 == NULL) SWIG_fail;
42628 temp6 = true;
42629 }
42630 }
42631 {
42632 PyThreadState* __tstate = wxPyBeginAllowThreads();
42633 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42634 wxPyEndAllowThreads(__tstate);
42635 if (PyErr_Occurred()) SWIG_fail;
42636 }
42637 {
42638 resultobj = wxPyMake_wxObject(result, (bool)0);
42639 }
42640 {
42641 if (temp4)
42642 delete arg4;
42643 }
42644 {
42645 if (temp6)
42646 delete arg6;
42647 }
42648 return resultobj;
42649 fail:
42650 {
42651 if (temp4)
42652 delete arg4;
42653 }
42654 {
42655 if (temp6)
42656 delete arg6;
42657 }
42658 return NULL;
42659 }
42660
42661
42662 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42663 PyObject *resultobj = 0;
42664 wxMenu *arg1 = (wxMenu *) 0 ;
42665 int arg2 ;
42666 wxString const &arg3_defvalue = wxPyEmptyString ;
42667 wxString *arg3 = (wxString *) &arg3_defvalue ;
42668 wxString const &arg4_defvalue = wxPyEmptyString ;
42669 wxString *arg4 = (wxString *) &arg4_defvalue ;
42670 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42671 wxMenuItem *result = 0 ;
42672 void *argp1 = 0 ;
42673 int res1 = 0 ;
42674 int val2 ;
42675 int ecode2 = 0 ;
42676 bool temp3 = false ;
42677 bool temp4 = false ;
42678 int val5 ;
42679 int ecode5 = 0 ;
42680 PyObject * obj0 = 0 ;
42681 PyObject * obj1 = 0 ;
42682 PyObject * obj2 = 0 ;
42683 PyObject * obj3 = 0 ;
42684 PyObject * obj4 = 0 ;
42685 char * kwnames[] = {
42686 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42687 };
42688
42689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42691 if (!SWIG_IsOK(res1)) {
42692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42693 }
42694 arg1 = reinterpret_cast< wxMenu * >(argp1);
42695 ecode2 = SWIG_AsVal_int(obj1, &val2);
42696 if (!SWIG_IsOK(ecode2)) {
42697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42698 }
42699 arg2 = static_cast< int >(val2);
42700 if (obj2) {
42701 {
42702 arg3 = wxString_in_helper(obj2);
42703 if (arg3 == NULL) SWIG_fail;
42704 temp3 = true;
42705 }
42706 }
42707 if (obj3) {
42708 {
42709 arg4 = wxString_in_helper(obj3);
42710 if (arg4 == NULL) SWIG_fail;
42711 temp4 = true;
42712 }
42713 }
42714 if (obj4) {
42715 ecode5 = SWIG_AsVal_int(obj4, &val5);
42716 if (!SWIG_IsOK(ecode5)) {
42717 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42718 }
42719 arg5 = static_cast< wxItemKind >(val5);
42720 }
42721 {
42722 PyThreadState* __tstate = wxPyBeginAllowThreads();
42723 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42724 wxPyEndAllowThreads(__tstate);
42725 if (PyErr_Occurred()) SWIG_fail;
42726 }
42727 {
42728 resultobj = wxPyMake_wxObject(result, (bool)0);
42729 }
42730 {
42731 if (temp3)
42732 delete arg3;
42733 }
42734 {
42735 if (temp4)
42736 delete arg4;
42737 }
42738 return resultobj;
42739 fail:
42740 {
42741 if (temp3)
42742 delete arg3;
42743 }
42744 {
42745 if (temp4)
42746 delete arg4;
42747 }
42748 return NULL;
42749 }
42750
42751
42752 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42753 PyObject *resultobj = 0;
42754 wxMenu *arg1 = (wxMenu *) 0 ;
42755 wxMenuItem *result = 0 ;
42756 void *argp1 = 0 ;
42757 int res1 = 0 ;
42758 PyObject *swig_obj[1] ;
42759
42760 if (!args) SWIG_fail;
42761 swig_obj[0] = args;
42762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42763 if (!SWIG_IsOK(res1)) {
42764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42765 }
42766 arg1 = reinterpret_cast< wxMenu * >(argp1);
42767 {
42768 PyThreadState* __tstate = wxPyBeginAllowThreads();
42769 result = (wxMenuItem *)(arg1)->PrependSeparator();
42770 wxPyEndAllowThreads(__tstate);
42771 if (PyErr_Occurred()) SWIG_fail;
42772 }
42773 {
42774 resultobj = wxPyMake_wxObject(result, (bool)0);
42775 }
42776 return resultobj;
42777 fail:
42778 return NULL;
42779 }
42780
42781
42782 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42783 PyObject *resultobj = 0;
42784 wxMenu *arg1 = (wxMenu *) 0 ;
42785 int arg2 ;
42786 wxString *arg3 = 0 ;
42787 wxString const &arg4_defvalue = wxPyEmptyString ;
42788 wxString *arg4 = (wxString *) &arg4_defvalue ;
42789 wxMenuItem *result = 0 ;
42790 void *argp1 = 0 ;
42791 int res1 = 0 ;
42792 int val2 ;
42793 int ecode2 = 0 ;
42794 bool temp3 = false ;
42795 bool temp4 = false ;
42796 PyObject * obj0 = 0 ;
42797 PyObject * obj1 = 0 ;
42798 PyObject * obj2 = 0 ;
42799 PyObject * obj3 = 0 ;
42800 char * kwnames[] = {
42801 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42802 };
42803
42804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42806 if (!SWIG_IsOK(res1)) {
42807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42808 }
42809 arg1 = reinterpret_cast< wxMenu * >(argp1);
42810 ecode2 = SWIG_AsVal_int(obj1, &val2);
42811 if (!SWIG_IsOK(ecode2)) {
42812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42813 }
42814 arg2 = static_cast< int >(val2);
42815 {
42816 arg3 = wxString_in_helper(obj2);
42817 if (arg3 == NULL) SWIG_fail;
42818 temp3 = true;
42819 }
42820 if (obj3) {
42821 {
42822 arg4 = wxString_in_helper(obj3);
42823 if (arg4 == NULL) SWIG_fail;
42824 temp4 = true;
42825 }
42826 }
42827 {
42828 PyThreadState* __tstate = wxPyBeginAllowThreads();
42829 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42830 wxPyEndAllowThreads(__tstate);
42831 if (PyErr_Occurred()) SWIG_fail;
42832 }
42833 {
42834 resultobj = wxPyMake_wxObject(result, (bool)0);
42835 }
42836 {
42837 if (temp3)
42838 delete arg3;
42839 }
42840 {
42841 if (temp4)
42842 delete arg4;
42843 }
42844 return resultobj;
42845 fail:
42846 {
42847 if (temp3)
42848 delete arg3;
42849 }
42850 {
42851 if (temp4)
42852 delete arg4;
42853 }
42854 return NULL;
42855 }
42856
42857
42858 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42859 PyObject *resultobj = 0;
42860 wxMenu *arg1 = (wxMenu *) 0 ;
42861 int arg2 ;
42862 wxString *arg3 = 0 ;
42863 wxString const &arg4_defvalue = wxPyEmptyString ;
42864 wxString *arg4 = (wxString *) &arg4_defvalue ;
42865 wxMenuItem *result = 0 ;
42866 void *argp1 = 0 ;
42867 int res1 = 0 ;
42868 int val2 ;
42869 int ecode2 = 0 ;
42870 bool temp3 = false ;
42871 bool temp4 = false ;
42872 PyObject * obj0 = 0 ;
42873 PyObject * obj1 = 0 ;
42874 PyObject * obj2 = 0 ;
42875 PyObject * obj3 = 0 ;
42876 char * kwnames[] = {
42877 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42878 };
42879
42880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42882 if (!SWIG_IsOK(res1)) {
42883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42884 }
42885 arg1 = reinterpret_cast< wxMenu * >(argp1);
42886 ecode2 = SWIG_AsVal_int(obj1, &val2);
42887 if (!SWIG_IsOK(ecode2)) {
42888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42889 }
42890 arg2 = static_cast< int >(val2);
42891 {
42892 arg3 = wxString_in_helper(obj2);
42893 if (arg3 == NULL) SWIG_fail;
42894 temp3 = true;
42895 }
42896 if (obj3) {
42897 {
42898 arg4 = wxString_in_helper(obj3);
42899 if (arg4 == NULL) SWIG_fail;
42900 temp4 = true;
42901 }
42902 }
42903 {
42904 PyThreadState* __tstate = wxPyBeginAllowThreads();
42905 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42906 wxPyEndAllowThreads(__tstate);
42907 if (PyErr_Occurred()) SWIG_fail;
42908 }
42909 {
42910 resultobj = wxPyMake_wxObject(result, (bool)0);
42911 }
42912 {
42913 if (temp3)
42914 delete arg3;
42915 }
42916 {
42917 if (temp4)
42918 delete arg4;
42919 }
42920 return resultobj;
42921 fail:
42922 {
42923 if (temp3)
42924 delete arg3;
42925 }
42926 {
42927 if (temp4)
42928 delete arg4;
42929 }
42930 return NULL;
42931 }
42932
42933
42934 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42935 PyObject *resultobj = 0;
42936 wxMenu *arg1 = (wxMenu *) 0 ;
42937 int arg2 ;
42938 wxString *arg3 = 0 ;
42939 wxMenu *arg4 = (wxMenu *) 0 ;
42940 wxString const &arg5_defvalue = wxPyEmptyString ;
42941 wxString *arg5 = (wxString *) &arg5_defvalue ;
42942 wxMenuItem *result = 0 ;
42943 void *argp1 = 0 ;
42944 int res1 = 0 ;
42945 int val2 ;
42946 int ecode2 = 0 ;
42947 bool temp3 = false ;
42948 void *argp4 = 0 ;
42949 int res4 = 0 ;
42950 bool temp5 = false ;
42951 PyObject * obj0 = 0 ;
42952 PyObject * obj1 = 0 ;
42953 PyObject * obj2 = 0 ;
42954 PyObject * obj3 = 0 ;
42955 PyObject * obj4 = 0 ;
42956 char * kwnames[] = {
42957 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42958 };
42959
42960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42962 if (!SWIG_IsOK(res1)) {
42963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42964 }
42965 arg1 = reinterpret_cast< wxMenu * >(argp1);
42966 ecode2 = SWIG_AsVal_int(obj1, &val2);
42967 if (!SWIG_IsOK(ecode2)) {
42968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
42969 }
42970 arg2 = static_cast< int >(val2);
42971 {
42972 arg3 = wxString_in_helper(obj2);
42973 if (arg3 == NULL) SWIG_fail;
42974 temp3 = true;
42975 }
42976 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42977 if (!SWIG_IsOK(res4)) {
42978 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42979 }
42980 arg4 = reinterpret_cast< wxMenu * >(argp4);
42981 if (obj4) {
42982 {
42983 arg5 = wxString_in_helper(obj4);
42984 if (arg5 == NULL) SWIG_fail;
42985 temp5 = true;
42986 }
42987 }
42988 {
42989 PyThreadState* __tstate = wxPyBeginAllowThreads();
42990 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42991 wxPyEndAllowThreads(__tstate);
42992 if (PyErr_Occurred()) SWIG_fail;
42993 }
42994 {
42995 resultobj = wxPyMake_wxObject(result, (bool)0);
42996 }
42997 {
42998 if (temp3)
42999 delete arg3;
43000 }
43001 {
43002 if (temp5)
43003 delete arg5;
43004 }
43005 return resultobj;
43006 fail:
43007 {
43008 if (temp3)
43009 delete arg3;
43010 }
43011 {
43012 if (temp5)
43013 delete arg5;
43014 }
43015 return NULL;
43016 }
43017
43018
43019 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43020 PyObject *resultobj = 0;
43021 wxMenu *arg1 = (wxMenu *) 0 ;
43022 int arg2 ;
43023 wxMenuItem *result = 0 ;
43024 void *argp1 = 0 ;
43025 int res1 = 0 ;
43026 int val2 ;
43027 int ecode2 = 0 ;
43028 PyObject * obj0 = 0 ;
43029 PyObject * obj1 = 0 ;
43030 char * kwnames[] = {
43031 (char *) "self",(char *) "id", NULL
43032 };
43033
43034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43036 if (!SWIG_IsOK(res1)) {
43037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43038 }
43039 arg1 = reinterpret_cast< wxMenu * >(argp1);
43040 ecode2 = SWIG_AsVal_int(obj1, &val2);
43041 if (!SWIG_IsOK(ecode2)) {
43042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43043 }
43044 arg2 = static_cast< int >(val2);
43045 {
43046 PyThreadState* __tstate = wxPyBeginAllowThreads();
43047 result = (wxMenuItem *)(arg1)->Remove(arg2);
43048 wxPyEndAllowThreads(__tstate);
43049 if (PyErr_Occurred()) SWIG_fail;
43050 }
43051 {
43052 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43053 }
43054 return resultobj;
43055 fail:
43056 return NULL;
43057 }
43058
43059
43060 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43061 PyObject *resultobj = 0;
43062 wxMenu *arg1 = (wxMenu *) 0 ;
43063 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43064 wxMenuItem *result = 0 ;
43065 void *argp1 = 0 ;
43066 int res1 = 0 ;
43067 void *argp2 = 0 ;
43068 int res2 = 0 ;
43069 PyObject * obj0 = 0 ;
43070 PyObject * obj1 = 0 ;
43071 char * kwnames[] = {
43072 (char *) "self",(char *) "item", NULL
43073 };
43074
43075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43077 if (!SWIG_IsOK(res1)) {
43078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43079 }
43080 arg1 = reinterpret_cast< wxMenu * >(argp1);
43081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43082 if (!SWIG_IsOK(res2)) {
43083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43084 }
43085 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43086 {
43087 PyThreadState* __tstate = wxPyBeginAllowThreads();
43088 result = (wxMenuItem *)(arg1)->Remove(arg2);
43089 wxPyEndAllowThreads(__tstate);
43090 if (PyErr_Occurred()) SWIG_fail;
43091 }
43092 {
43093 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43094 }
43095 return resultobj;
43096 fail:
43097 return NULL;
43098 }
43099
43100
43101 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43102 PyObject *resultobj = 0;
43103 wxMenu *arg1 = (wxMenu *) 0 ;
43104 int arg2 ;
43105 bool result;
43106 void *argp1 = 0 ;
43107 int res1 = 0 ;
43108 int val2 ;
43109 int ecode2 = 0 ;
43110 PyObject * obj0 = 0 ;
43111 PyObject * obj1 = 0 ;
43112 char * kwnames[] = {
43113 (char *) "self",(char *) "id", NULL
43114 };
43115
43116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43118 if (!SWIG_IsOK(res1)) {
43119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43120 }
43121 arg1 = reinterpret_cast< wxMenu * >(argp1);
43122 ecode2 = SWIG_AsVal_int(obj1, &val2);
43123 if (!SWIG_IsOK(ecode2)) {
43124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43125 }
43126 arg2 = static_cast< int >(val2);
43127 {
43128 PyThreadState* __tstate = wxPyBeginAllowThreads();
43129 result = (bool)(arg1)->Delete(arg2);
43130 wxPyEndAllowThreads(__tstate);
43131 if (PyErr_Occurred()) SWIG_fail;
43132 }
43133 {
43134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43135 }
43136 return resultobj;
43137 fail:
43138 return NULL;
43139 }
43140
43141
43142 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43143 PyObject *resultobj = 0;
43144 wxMenu *arg1 = (wxMenu *) 0 ;
43145 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43146 bool result;
43147 void *argp1 = 0 ;
43148 int res1 = 0 ;
43149 void *argp2 = 0 ;
43150 int res2 = 0 ;
43151 PyObject * obj0 = 0 ;
43152 PyObject * obj1 = 0 ;
43153 char * kwnames[] = {
43154 (char *) "self",(char *) "item", NULL
43155 };
43156
43157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43159 if (!SWIG_IsOK(res1)) {
43160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43161 }
43162 arg1 = reinterpret_cast< wxMenu * >(argp1);
43163 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43164 if (!SWIG_IsOK(res2)) {
43165 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43166 }
43167 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43168 {
43169 PyThreadState* __tstate = wxPyBeginAllowThreads();
43170 result = (bool)(arg1)->Delete(arg2);
43171 wxPyEndAllowThreads(__tstate);
43172 if (PyErr_Occurred()) SWIG_fail;
43173 }
43174 {
43175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43176 }
43177 return resultobj;
43178 fail:
43179 return NULL;
43180 }
43181
43182
43183 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43184 PyObject *resultobj = 0;
43185 wxMenu *arg1 = (wxMenu *) 0 ;
43186 void *argp1 = 0 ;
43187 int res1 = 0 ;
43188 PyObject *swig_obj[1] ;
43189
43190 if (!args) SWIG_fail;
43191 swig_obj[0] = args;
43192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43193 if (!SWIG_IsOK(res1)) {
43194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43195 }
43196 arg1 = reinterpret_cast< wxMenu * >(argp1);
43197 {
43198 PyThreadState* __tstate = wxPyBeginAllowThreads();
43199 wxMenu_Destroy(arg1);
43200 wxPyEndAllowThreads(__tstate);
43201 if (PyErr_Occurred()) SWIG_fail;
43202 }
43203 resultobj = SWIG_Py_Void();
43204 return resultobj;
43205 fail:
43206 return NULL;
43207 }
43208
43209
43210 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43211 PyObject *resultobj = 0;
43212 wxMenu *arg1 = (wxMenu *) 0 ;
43213 int arg2 ;
43214 bool result;
43215 void *argp1 = 0 ;
43216 int res1 = 0 ;
43217 int val2 ;
43218 int ecode2 = 0 ;
43219 PyObject * obj0 = 0 ;
43220 PyObject * obj1 = 0 ;
43221 char * kwnames[] = {
43222 (char *) "self",(char *) "id", NULL
43223 };
43224
43225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43227 if (!SWIG_IsOK(res1)) {
43228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43229 }
43230 arg1 = reinterpret_cast< wxMenu * >(argp1);
43231 ecode2 = SWIG_AsVal_int(obj1, &val2);
43232 if (!SWIG_IsOK(ecode2)) {
43233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43234 }
43235 arg2 = static_cast< int >(val2);
43236 {
43237 PyThreadState* __tstate = wxPyBeginAllowThreads();
43238 result = (bool)(arg1)->Destroy(arg2);
43239 wxPyEndAllowThreads(__tstate);
43240 if (PyErr_Occurred()) SWIG_fail;
43241 }
43242 {
43243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43244 }
43245 return resultobj;
43246 fail:
43247 return NULL;
43248 }
43249
43250
43251 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43252 PyObject *resultobj = 0;
43253 wxMenu *arg1 = (wxMenu *) 0 ;
43254 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43255 bool result;
43256 void *argp1 = 0 ;
43257 int res1 = 0 ;
43258 void *argp2 = 0 ;
43259 int res2 = 0 ;
43260 PyObject * obj0 = 0 ;
43261 PyObject * obj1 = 0 ;
43262 char * kwnames[] = {
43263 (char *) "self",(char *) "item", NULL
43264 };
43265
43266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43268 if (!SWIG_IsOK(res1)) {
43269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43270 }
43271 arg1 = reinterpret_cast< wxMenu * >(argp1);
43272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43273 if (!SWIG_IsOK(res2)) {
43274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43275 }
43276 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43277 {
43278 PyThreadState* __tstate = wxPyBeginAllowThreads();
43279 result = (bool)(arg1)->Destroy(arg2);
43280 wxPyEndAllowThreads(__tstate);
43281 if (PyErr_Occurred()) SWIG_fail;
43282 }
43283 {
43284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43285 }
43286 return resultobj;
43287 fail:
43288 return NULL;
43289 }
43290
43291
43292 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43293 PyObject *resultobj = 0;
43294 wxMenu *arg1 = (wxMenu *) 0 ;
43295 size_t result;
43296 void *argp1 = 0 ;
43297 int res1 = 0 ;
43298 PyObject *swig_obj[1] ;
43299
43300 if (!args) SWIG_fail;
43301 swig_obj[0] = args;
43302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43303 if (!SWIG_IsOK(res1)) {
43304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43305 }
43306 arg1 = reinterpret_cast< wxMenu * >(argp1);
43307 {
43308 PyThreadState* __tstate = wxPyBeginAllowThreads();
43309 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43310 wxPyEndAllowThreads(__tstate);
43311 if (PyErr_Occurred()) SWIG_fail;
43312 }
43313 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43314 return resultobj;
43315 fail:
43316 return NULL;
43317 }
43318
43319
43320 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43321 PyObject *resultobj = 0;
43322 wxMenu *arg1 = (wxMenu *) 0 ;
43323 PyObject *result = 0 ;
43324 void *argp1 = 0 ;
43325 int res1 = 0 ;
43326 PyObject *swig_obj[1] ;
43327
43328 if (!args) SWIG_fail;
43329 swig_obj[0] = args;
43330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43331 if (!SWIG_IsOK(res1)) {
43332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43333 }
43334 arg1 = reinterpret_cast< wxMenu * >(argp1);
43335 {
43336 PyThreadState* __tstate = wxPyBeginAllowThreads();
43337 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43338 wxPyEndAllowThreads(__tstate);
43339 if (PyErr_Occurred()) SWIG_fail;
43340 }
43341 resultobj = result;
43342 return resultobj;
43343 fail:
43344 return NULL;
43345 }
43346
43347
43348 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43349 PyObject *resultobj = 0;
43350 wxMenu *arg1 = (wxMenu *) 0 ;
43351 wxString *arg2 = 0 ;
43352 int result;
43353 void *argp1 = 0 ;
43354 int res1 = 0 ;
43355 bool temp2 = false ;
43356 PyObject * obj0 = 0 ;
43357 PyObject * obj1 = 0 ;
43358 char * kwnames[] = {
43359 (char *) "self",(char *) "item", NULL
43360 };
43361
43362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43364 if (!SWIG_IsOK(res1)) {
43365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43366 }
43367 arg1 = reinterpret_cast< wxMenu * >(argp1);
43368 {
43369 arg2 = wxString_in_helper(obj1);
43370 if (arg2 == NULL) SWIG_fail;
43371 temp2 = true;
43372 }
43373 {
43374 PyThreadState* __tstate = wxPyBeginAllowThreads();
43375 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43376 wxPyEndAllowThreads(__tstate);
43377 if (PyErr_Occurred()) SWIG_fail;
43378 }
43379 resultobj = SWIG_From_int(static_cast< int >(result));
43380 {
43381 if (temp2)
43382 delete arg2;
43383 }
43384 return resultobj;
43385 fail:
43386 {
43387 if (temp2)
43388 delete arg2;
43389 }
43390 return NULL;
43391 }
43392
43393
43394 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43395 PyObject *resultobj = 0;
43396 wxMenu *arg1 = (wxMenu *) 0 ;
43397 int arg2 ;
43398 wxMenuItem *result = 0 ;
43399 void *argp1 = 0 ;
43400 int res1 = 0 ;
43401 int val2 ;
43402 int ecode2 = 0 ;
43403 PyObject * obj0 = 0 ;
43404 PyObject * obj1 = 0 ;
43405 char * kwnames[] = {
43406 (char *) "self",(char *) "id", NULL
43407 };
43408
43409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43411 if (!SWIG_IsOK(res1)) {
43412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43413 }
43414 arg1 = reinterpret_cast< wxMenu * >(argp1);
43415 ecode2 = SWIG_AsVal_int(obj1, &val2);
43416 if (!SWIG_IsOK(ecode2)) {
43417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43418 }
43419 arg2 = static_cast< int >(val2);
43420 {
43421 PyThreadState* __tstate = wxPyBeginAllowThreads();
43422 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43423 wxPyEndAllowThreads(__tstate);
43424 if (PyErr_Occurred()) SWIG_fail;
43425 }
43426 {
43427 resultobj = wxPyMake_wxObject(result, (bool)0);
43428 }
43429 return resultobj;
43430 fail:
43431 return NULL;
43432 }
43433
43434
43435 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43436 PyObject *resultobj = 0;
43437 wxMenu *arg1 = (wxMenu *) 0 ;
43438 size_t arg2 ;
43439 wxMenuItem *result = 0 ;
43440 void *argp1 = 0 ;
43441 int res1 = 0 ;
43442 size_t val2 ;
43443 int ecode2 = 0 ;
43444 PyObject * obj0 = 0 ;
43445 PyObject * obj1 = 0 ;
43446 char * kwnames[] = {
43447 (char *) "self",(char *) "position", NULL
43448 };
43449
43450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43452 if (!SWIG_IsOK(res1)) {
43453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43454 }
43455 arg1 = reinterpret_cast< wxMenu * >(argp1);
43456 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43457 if (!SWIG_IsOK(ecode2)) {
43458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43459 }
43460 arg2 = static_cast< size_t >(val2);
43461 {
43462 PyThreadState* __tstate = wxPyBeginAllowThreads();
43463 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43464 wxPyEndAllowThreads(__tstate);
43465 if (PyErr_Occurred()) SWIG_fail;
43466 }
43467 {
43468 resultobj = wxPyMake_wxObject(result, (bool)0);
43469 }
43470 return resultobj;
43471 fail:
43472 return NULL;
43473 }
43474
43475
43476 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43477 PyObject *resultobj = 0;
43478 wxMenu *arg1 = (wxMenu *) 0 ;
43479 int arg2 ;
43480 bool arg3 ;
43481 void *argp1 = 0 ;
43482 int res1 = 0 ;
43483 int val2 ;
43484 int ecode2 = 0 ;
43485 bool val3 ;
43486 int ecode3 = 0 ;
43487 PyObject * obj0 = 0 ;
43488 PyObject * obj1 = 0 ;
43489 PyObject * obj2 = 0 ;
43490 char * kwnames[] = {
43491 (char *) "self",(char *) "id",(char *) "enable", NULL
43492 };
43493
43494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43496 if (!SWIG_IsOK(res1)) {
43497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43498 }
43499 arg1 = reinterpret_cast< wxMenu * >(argp1);
43500 ecode2 = SWIG_AsVal_int(obj1, &val2);
43501 if (!SWIG_IsOK(ecode2)) {
43502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43503 }
43504 arg2 = static_cast< int >(val2);
43505 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43506 if (!SWIG_IsOK(ecode3)) {
43507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43508 }
43509 arg3 = static_cast< bool >(val3);
43510 {
43511 PyThreadState* __tstate = wxPyBeginAllowThreads();
43512 (arg1)->Enable(arg2,arg3);
43513 wxPyEndAllowThreads(__tstate);
43514 if (PyErr_Occurred()) SWIG_fail;
43515 }
43516 resultobj = SWIG_Py_Void();
43517 return resultobj;
43518 fail:
43519 return NULL;
43520 }
43521
43522
43523 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43524 PyObject *resultobj = 0;
43525 wxMenu *arg1 = (wxMenu *) 0 ;
43526 int arg2 ;
43527 bool result;
43528 void *argp1 = 0 ;
43529 int res1 = 0 ;
43530 int val2 ;
43531 int ecode2 = 0 ;
43532 PyObject * obj0 = 0 ;
43533 PyObject * obj1 = 0 ;
43534 char * kwnames[] = {
43535 (char *) "self",(char *) "id", NULL
43536 };
43537
43538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43540 if (!SWIG_IsOK(res1)) {
43541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43542 }
43543 arg1 = reinterpret_cast< wxMenu * >(argp1);
43544 ecode2 = SWIG_AsVal_int(obj1, &val2);
43545 if (!SWIG_IsOK(ecode2)) {
43546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43547 }
43548 arg2 = static_cast< int >(val2);
43549 {
43550 PyThreadState* __tstate = wxPyBeginAllowThreads();
43551 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43552 wxPyEndAllowThreads(__tstate);
43553 if (PyErr_Occurred()) SWIG_fail;
43554 }
43555 {
43556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43557 }
43558 return resultobj;
43559 fail:
43560 return NULL;
43561 }
43562
43563
43564 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43565 PyObject *resultobj = 0;
43566 wxMenu *arg1 = (wxMenu *) 0 ;
43567 int arg2 ;
43568 bool arg3 ;
43569 void *argp1 = 0 ;
43570 int res1 = 0 ;
43571 int val2 ;
43572 int ecode2 = 0 ;
43573 bool val3 ;
43574 int ecode3 = 0 ;
43575 PyObject * obj0 = 0 ;
43576 PyObject * obj1 = 0 ;
43577 PyObject * obj2 = 0 ;
43578 char * kwnames[] = {
43579 (char *) "self",(char *) "id",(char *) "check", NULL
43580 };
43581
43582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43584 if (!SWIG_IsOK(res1)) {
43585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43586 }
43587 arg1 = reinterpret_cast< wxMenu * >(argp1);
43588 ecode2 = SWIG_AsVal_int(obj1, &val2);
43589 if (!SWIG_IsOK(ecode2)) {
43590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43591 }
43592 arg2 = static_cast< int >(val2);
43593 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43594 if (!SWIG_IsOK(ecode3)) {
43595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43596 }
43597 arg3 = static_cast< bool >(val3);
43598 {
43599 PyThreadState* __tstate = wxPyBeginAllowThreads();
43600 (arg1)->Check(arg2,arg3);
43601 wxPyEndAllowThreads(__tstate);
43602 if (PyErr_Occurred()) SWIG_fail;
43603 }
43604 resultobj = SWIG_Py_Void();
43605 return resultobj;
43606 fail:
43607 return NULL;
43608 }
43609
43610
43611 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43612 PyObject *resultobj = 0;
43613 wxMenu *arg1 = (wxMenu *) 0 ;
43614 int arg2 ;
43615 bool result;
43616 void *argp1 = 0 ;
43617 int res1 = 0 ;
43618 int val2 ;
43619 int ecode2 = 0 ;
43620 PyObject * obj0 = 0 ;
43621 PyObject * obj1 = 0 ;
43622 char * kwnames[] = {
43623 (char *) "self",(char *) "id", NULL
43624 };
43625
43626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43628 if (!SWIG_IsOK(res1)) {
43629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43630 }
43631 arg1 = reinterpret_cast< wxMenu * >(argp1);
43632 ecode2 = SWIG_AsVal_int(obj1, &val2);
43633 if (!SWIG_IsOK(ecode2)) {
43634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43635 }
43636 arg2 = static_cast< int >(val2);
43637 {
43638 PyThreadState* __tstate = wxPyBeginAllowThreads();
43639 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43640 wxPyEndAllowThreads(__tstate);
43641 if (PyErr_Occurred()) SWIG_fail;
43642 }
43643 {
43644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43645 }
43646 return resultobj;
43647 fail:
43648 return NULL;
43649 }
43650
43651
43652 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43653 PyObject *resultobj = 0;
43654 wxMenu *arg1 = (wxMenu *) 0 ;
43655 int arg2 ;
43656 wxString *arg3 = 0 ;
43657 void *argp1 = 0 ;
43658 int res1 = 0 ;
43659 int val2 ;
43660 int ecode2 = 0 ;
43661 bool temp3 = false ;
43662 PyObject * obj0 = 0 ;
43663 PyObject * obj1 = 0 ;
43664 PyObject * obj2 = 0 ;
43665 char * kwnames[] = {
43666 (char *) "self",(char *) "id",(char *) "label", NULL
43667 };
43668
43669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43671 if (!SWIG_IsOK(res1)) {
43672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43673 }
43674 arg1 = reinterpret_cast< wxMenu * >(argp1);
43675 ecode2 = SWIG_AsVal_int(obj1, &val2);
43676 if (!SWIG_IsOK(ecode2)) {
43677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43678 }
43679 arg2 = static_cast< int >(val2);
43680 {
43681 arg3 = wxString_in_helper(obj2);
43682 if (arg3 == NULL) SWIG_fail;
43683 temp3 = true;
43684 }
43685 {
43686 PyThreadState* __tstate = wxPyBeginAllowThreads();
43687 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43688 wxPyEndAllowThreads(__tstate);
43689 if (PyErr_Occurred()) SWIG_fail;
43690 }
43691 resultobj = SWIG_Py_Void();
43692 {
43693 if (temp3)
43694 delete arg3;
43695 }
43696 return resultobj;
43697 fail:
43698 {
43699 if (temp3)
43700 delete arg3;
43701 }
43702 return NULL;
43703 }
43704
43705
43706 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43707 PyObject *resultobj = 0;
43708 wxMenu *arg1 = (wxMenu *) 0 ;
43709 int arg2 ;
43710 wxString result;
43711 void *argp1 = 0 ;
43712 int res1 = 0 ;
43713 int val2 ;
43714 int ecode2 = 0 ;
43715 PyObject * obj0 = 0 ;
43716 PyObject * obj1 = 0 ;
43717 char * kwnames[] = {
43718 (char *) "self",(char *) "id", NULL
43719 };
43720
43721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43723 if (!SWIG_IsOK(res1)) {
43724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43725 }
43726 arg1 = reinterpret_cast< wxMenu * >(argp1);
43727 ecode2 = SWIG_AsVal_int(obj1, &val2);
43728 if (!SWIG_IsOK(ecode2)) {
43729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43730 }
43731 arg2 = static_cast< int >(val2);
43732 {
43733 PyThreadState* __tstate = wxPyBeginAllowThreads();
43734 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43735 wxPyEndAllowThreads(__tstate);
43736 if (PyErr_Occurred()) SWIG_fail;
43737 }
43738 {
43739 #if wxUSE_UNICODE
43740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43741 #else
43742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43743 #endif
43744 }
43745 return resultobj;
43746 fail:
43747 return NULL;
43748 }
43749
43750
43751 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43752 PyObject *resultobj = 0;
43753 wxMenu *arg1 = (wxMenu *) 0 ;
43754 int arg2 ;
43755 wxString *arg3 = 0 ;
43756 void *argp1 = 0 ;
43757 int res1 = 0 ;
43758 int val2 ;
43759 int ecode2 = 0 ;
43760 bool temp3 = false ;
43761 PyObject * obj0 = 0 ;
43762 PyObject * obj1 = 0 ;
43763 PyObject * obj2 = 0 ;
43764 char * kwnames[] = {
43765 (char *) "self",(char *) "id",(char *) "helpString", NULL
43766 };
43767
43768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43770 if (!SWIG_IsOK(res1)) {
43771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43772 }
43773 arg1 = reinterpret_cast< wxMenu * >(argp1);
43774 ecode2 = SWIG_AsVal_int(obj1, &val2);
43775 if (!SWIG_IsOK(ecode2)) {
43776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43777 }
43778 arg2 = static_cast< int >(val2);
43779 {
43780 arg3 = wxString_in_helper(obj2);
43781 if (arg3 == NULL) SWIG_fail;
43782 temp3 = true;
43783 }
43784 {
43785 PyThreadState* __tstate = wxPyBeginAllowThreads();
43786 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43787 wxPyEndAllowThreads(__tstate);
43788 if (PyErr_Occurred()) SWIG_fail;
43789 }
43790 resultobj = SWIG_Py_Void();
43791 {
43792 if (temp3)
43793 delete arg3;
43794 }
43795 return resultobj;
43796 fail:
43797 {
43798 if (temp3)
43799 delete arg3;
43800 }
43801 return NULL;
43802 }
43803
43804
43805 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43806 PyObject *resultobj = 0;
43807 wxMenu *arg1 = (wxMenu *) 0 ;
43808 int arg2 ;
43809 wxString result;
43810 void *argp1 = 0 ;
43811 int res1 = 0 ;
43812 int val2 ;
43813 int ecode2 = 0 ;
43814 PyObject * obj0 = 0 ;
43815 PyObject * obj1 = 0 ;
43816 char * kwnames[] = {
43817 (char *) "self",(char *) "id", NULL
43818 };
43819
43820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43822 if (!SWIG_IsOK(res1)) {
43823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43824 }
43825 arg1 = reinterpret_cast< wxMenu * >(argp1);
43826 ecode2 = SWIG_AsVal_int(obj1, &val2);
43827 if (!SWIG_IsOK(ecode2)) {
43828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43829 }
43830 arg2 = static_cast< int >(val2);
43831 {
43832 PyThreadState* __tstate = wxPyBeginAllowThreads();
43833 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43834 wxPyEndAllowThreads(__tstate);
43835 if (PyErr_Occurred()) SWIG_fail;
43836 }
43837 {
43838 #if wxUSE_UNICODE
43839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43840 #else
43841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43842 #endif
43843 }
43844 return resultobj;
43845 fail:
43846 return NULL;
43847 }
43848
43849
43850 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43851 PyObject *resultobj = 0;
43852 wxMenu *arg1 = (wxMenu *) 0 ;
43853 wxString *arg2 = 0 ;
43854 void *argp1 = 0 ;
43855 int res1 = 0 ;
43856 bool temp2 = false ;
43857 PyObject * obj0 = 0 ;
43858 PyObject * obj1 = 0 ;
43859 char * kwnames[] = {
43860 (char *) "self",(char *) "title", NULL
43861 };
43862
43863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43865 if (!SWIG_IsOK(res1)) {
43866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43867 }
43868 arg1 = reinterpret_cast< wxMenu * >(argp1);
43869 {
43870 arg2 = wxString_in_helper(obj1);
43871 if (arg2 == NULL) SWIG_fail;
43872 temp2 = true;
43873 }
43874 {
43875 PyThreadState* __tstate = wxPyBeginAllowThreads();
43876 (arg1)->SetTitle((wxString const &)*arg2);
43877 wxPyEndAllowThreads(__tstate);
43878 if (PyErr_Occurred()) SWIG_fail;
43879 }
43880 resultobj = SWIG_Py_Void();
43881 {
43882 if (temp2)
43883 delete arg2;
43884 }
43885 return resultobj;
43886 fail:
43887 {
43888 if (temp2)
43889 delete arg2;
43890 }
43891 return NULL;
43892 }
43893
43894
43895 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43896 PyObject *resultobj = 0;
43897 wxMenu *arg1 = (wxMenu *) 0 ;
43898 wxString result;
43899 void *argp1 = 0 ;
43900 int res1 = 0 ;
43901 PyObject *swig_obj[1] ;
43902
43903 if (!args) SWIG_fail;
43904 swig_obj[0] = args;
43905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43906 if (!SWIG_IsOK(res1)) {
43907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43908 }
43909 arg1 = reinterpret_cast< wxMenu * >(argp1);
43910 {
43911 PyThreadState* __tstate = wxPyBeginAllowThreads();
43912 result = ((wxMenu const *)arg1)->GetTitle();
43913 wxPyEndAllowThreads(__tstate);
43914 if (PyErr_Occurred()) SWIG_fail;
43915 }
43916 {
43917 #if wxUSE_UNICODE
43918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43919 #else
43920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43921 #endif
43922 }
43923 return resultobj;
43924 fail:
43925 return NULL;
43926 }
43927
43928
43929 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43930 PyObject *resultobj = 0;
43931 wxMenu *arg1 = (wxMenu *) 0 ;
43932 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43933 void *argp1 = 0 ;
43934 int res1 = 0 ;
43935 void *argp2 = 0 ;
43936 int res2 = 0 ;
43937 PyObject * obj0 = 0 ;
43938 PyObject * obj1 = 0 ;
43939 char * kwnames[] = {
43940 (char *) "self",(char *) "handler", NULL
43941 };
43942
43943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43945 if (!SWIG_IsOK(res1)) {
43946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43947 }
43948 arg1 = reinterpret_cast< wxMenu * >(argp1);
43949 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43950 if (!SWIG_IsOK(res2)) {
43951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43952 }
43953 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43954 {
43955 PyThreadState* __tstate = wxPyBeginAllowThreads();
43956 (arg1)->SetEventHandler(arg2);
43957 wxPyEndAllowThreads(__tstate);
43958 if (PyErr_Occurred()) SWIG_fail;
43959 }
43960 resultobj = SWIG_Py_Void();
43961 return resultobj;
43962 fail:
43963 return NULL;
43964 }
43965
43966
43967 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43968 PyObject *resultobj = 0;
43969 wxMenu *arg1 = (wxMenu *) 0 ;
43970 wxEvtHandler *result = 0 ;
43971 void *argp1 = 0 ;
43972 int res1 = 0 ;
43973 PyObject *swig_obj[1] ;
43974
43975 if (!args) SWIG_fail;
43976 swig_obj[0] = args;
43977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43978 if (!SWIG_IsOK(res1)) {
43979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
43980 }
43981 arg1 = reinterpret_cast< wxMenu * >(argp1);
43982 {
43983 PyThreadState* __tstate = wxPyBeginAllowThreads();
43984 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
43985 wxPyEndAllowThreads(__tstate);
43986 if (PyErr_Occurred()) SWIG_fail;
43987 }
43988 {
43989 resultobj = wxPyMake_wxObject(result, 0);
43990 }
43991 return resultobj;
43992 fail:
43993 return NULL;
43994 }
43995
43996
43997 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43998 PyObject *resultobj = 0;
43999 wxMenu *arg1 = (wxMenu *) 0 ;
44000 wxWindow *arg2 = (wxWindow *) 0 ;
44001 void *argp1 = 0 ;
44002 int res1 = 0 ;
44003 void *argp2 = 0 ;
44004 int res2 = 0 ;
44005 PyObject * obj0 = 0 ;
44006 PyObject * obj1 = 0 ;
44007 char * kwnames[] = {
44008 (char *) "self",(char *) "win", NULL
44009 };
44010
44011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44013 if (!SWIG_IsOK(res1)) {
44014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44015 }
44016 arg1 = reinterpret_cast< wxMenu * >(argp1);
44017 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44018 if (!SWIG_IsOK(res2)) {
44019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44020 }
44021 arg2 = reinterpret_cast< wxWindow * >(argp2);
44022 {
44023 PyThreadState* __tstate = wxPyBeginAllowThreads();
44024 (arg1)->SetInvokingWindow(arg2);
44025 wxPyEndAllowThreads(__tstate);
44026 if (PyErr_Occurred()) SWIG_fail;
44027 }
44028 resultobj = SWIG_Py_Void();
44029 return resultobj;
44030 fail:
44031 return NULL;
44032 }
44033
44034
44035 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44036 PyObject *resultobj = 0;
44037 wxMenu *arg1 = (wxMenu *) 0 ;
44038 wxWindow *result = 0 ;
44039 void *argp1 = 0 ;
44040 int res1 = 0 ;
44041 PyObject *swig_obj[1] ;
44042
44043 if (!args) SWIG_fail;
44044 swig_obj[0] = args;
44045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44046 if (!SWIG_IsOK(res1)) {
44047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44048 }
44049 arg1 = reinterpret_cast< wxMenu * >(argp1);
44050 {
44051 PyThreadState* __tstate = wxPyBeginAllowThreads();
44052 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44053 wxPyEndAllowThreads(__tstate);
44054 if (PyErr_Occurred()) SWIG_fail;
44055 }
44056 {
44057 resultobj = wxPyMake_wxObject(result, 0);
44058 }
44059 return resultobj;
44060 fail:
44061 return NULL;
44062 }
44063
44064
44065 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44066 PyObject *resultobj = 0;
44067 wxMenu *arg1 = (wxMenu *) 0 ;
44068 long result;
44069 void *argp1 = 0 ;
44070 int res1 = 0 ;
44071 PyObject *swig_obj[1] ;
44072
44073 if (!args) SWIG_fail;
44074 swig_obj[0] = args;
44075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44076 if (!SWIG_IsOK(res1)) {
44077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44078 }
44079 arg1 = reinterpret_cast< wxMenu * >(argp1);
44080 {
44081 PyThreadState* __tstate = wxPyBeginAllowThreads();
44082 result = (long)((wxMenu const *)arg1)->GetStyle();
44083 wxPyEndAllowThreads(__tstate);
44084 if (PyErr_Occurred()) SWIG_fail;
44085 }
44086 resultobj = SWIG_From_long(static_cast< long >(result));
44087 return resultobj;
44088 fail:
44089 return NULL;
44090 }
44091
44092
44093 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44094 PyObject *resultobj = 0;
44095 wxMenu *arg1 = (wxMenu *) 0 ;
44096 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44097 void *argp1 = 0 ;
44098 int res1 = 0 ;
44099 void *argp2 = 0 ;
44100 int res2 = 0 ;
44101 PyObject * obj0 = 0 ;
44102 PyObject * obj1 = 0 ;
44103 char * kwnames[] = {
44104 (char *) "self",(char *) "source", NULL
44105 };
44106
44107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44109 if (!SWIG_IsOK(res1)) {
44110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44111 }
44112 arg1 = reinterpret_cast< wxMenu * >(argp1);
44113 if (obj1) {
44114 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44115 if (!SWIG_IsOK(res2)) {
44116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44117 }
44118 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44119 }
44120 {
44121 PyThreadState* __tstate = wxPyBeginAllowThreads();
44122 (arg1)->UpdateUI(arg2);
44123 wxPyEndAllowThreads(__tstate);
44124 if (PyErr_Occurred()) SWIG_fail;
44125 }
44126 resultobj = SWIG_Py_Void();
44127 return resultobj;
44128 fail:
44129 return NULL;
44130 }
44131
44132
44133 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44134 PyObject *resultobj = 0;
44135 wxMenu *arg1 = (wxMenu *) 0 ;
44136 wxMenuBar *result = 0 ;
44137 void *argp1 = 0 ;
44138 int res1 = 0 ;
44139 PyObject *swig_obj[1] ;
44140
44141 if (!args) SWIG_fail;
44142 swig_obj[0] = args;
44143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44144 if (!SWIG_IsOK(res1)) {
44145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44146 }
44147 arg1 = reinterpret_cast< wxMenu * >(argp1);
44148 {
44149 PyThreadState* __tstate = wxPyBeginAllowThreads();
44150 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44151 wxPyEndAllowThreads(__tstate);
44152 if (PyErr_Occurred()) SWIG_fail;
44153 }
44154 {
44155 resultobj = wxPyMake_wxObject(result, (bool)0);
44156 }
44157 return resultobj;
44158 fail:
44159 return NULL;
44160 }
44161
44162
44163 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44164 PyObject *resultobj = 0;
44165 wxMenu *arg1 = (wxMenu *) 0 ;
44166 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44167 void *argp1 = 0 ;
44168 int res1 = 0 ;
44169 void *argp2 = 0 ;
44170 int res2 = 0 ;
44171 PyObject * obj0 = 0 ;
44172 PyObject * obj1 = 0 ;
44173 char * kwnames[] = {
44174 (char *) "self",(char *) "menubar", NULL
44175 };
44176
44177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44179 if (!SWIG_IsOK(res1)) {
44180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44181 }
44182 arg1 = reinterpret_cast< wxMenu * >(argp1);
44183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44184 if (!SWIG_IsOK(res2)) {
44185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44186 }
44187 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44188 {
44189 PyThreadState* __tstate = wxPyBeginAllowThreads();
44190 (arg1)->Attach(arg2);
44191 wxPyEndAllowThreads(__tstate);
44192 if (PyErr_Occurred()) SWIG_fail;
44193 }
44194 resultobj = SWIG_Py_Void();
44195 return resultobj;
44196 fail:
44197 return NULL;
44198 }
44199
44200
44201 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44202 PyObject *resultobj = 0;
44203 wxMenu *arg1 = (wxMenu *) 0 ;
44204 void *argp1 = 0 ;
44205 int res1 = 0 ;
44206 PyObject *swig_obj[1] ;
44207
44208 if (!args) SWIG_fail;
44209 swig_obj[0] = args;
44210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44211 if (!SWIG_IsOK(res1)) {
44212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44213 }
44214 arg1 = reinterpret_cast< wxMenu * >(argp1);
44215 {
44216 PyThreadState* __tstate = wxPyBeginAllowThreads();
44217 (arg1)->Detach();
44218 wxPyEndAllowThreads(__tstate);
44219 if (PyErr_Occurred()) SWIG_fail;
44220 }
44221 resultobj = SWIG_Py_Void();
44222 return resultobj;
44223 fail:
44224 return NULL;
44225 }
44226
44227
44228 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44229 PyObject *resultobj = 0;
44230 wxMenu *arg1 = (wxMenu *) 0 ;
44231 bool result;
44232 void *argp1 = 0 ;
44233 int res1 = 0 ;
44234 PyObject *swig_obj[1] ;
44235
44236 if (!args) SWIG_fail;
44237 swig_obj[0] = args;
44238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44239 if (!SWIG_IsOK(res1)) {
44240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44241 }
44242 arg1 = reinterpret_cast< wxMenu * >(argp1);
44243 {
44244 PyThreadState* __tstate = wxPyBeginAllowThreads();
44245 result = (bool)((wxMenu const *)arg1)->IsAttached();
44246 wxPyEndAllowThreads(__tstate);
44247 if (PyErr_Occurred()) SWIG_fail;
44248 }
44249 {
44250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44251 }
44252 return resultobj;
44253 fail:
44254 return NULL;
44255 }
44256
44257
44258 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44259 PyObject *resultobj = 0;
44260 wxMenu *arg1 = (wxMenu *) 0 ;
44261 wxMenu *arg2 = (wxMenu *) 0 ;
44262 void *argp1 = 0 ;
44263 int res1 = 0 ;
44264 void *argp2 = 0 ;
44265 int res2 = 0 ;
44266 PyObject * obj0 = 0 ;
44267 PyObject * obj1 = 0 ;
44268 char * kwnames[] = {
44269 (char *) "self",(char *) "parent", NULL
44270 };
44271
44272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44274 if (!SWIG_IsOK(res1)) {
44275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44276 }
44277 arg1 = reinterpret_cast< wxMenu * >(argp1);
44278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44279 if (!SWIG_IsOK(res2)) {
44280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44281 }
44282 arg2 = reinterpret_cast< wxMenu * >(argp2);
44283 {
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 (arg1)->SetParent(arg2);
44286 wxPyEndAllowThreads(__tstate);
44287 if (PyErr_Occurred()) SWIG_fail;
44288 }
44289 resultobj = SWIG_Py_Void();
44290 return resultobj;
44291 fail:
44292 return NULL;
44293 }
44294
44295
44296 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44297 PyObject *resultobj = 0;
44298 wxMenu *arg1 = (wxMenu *) 0 ;
44299 wxMenu *result = 0 ;
44300 void *argp1 = 0 ;
44301 int res1 = 0 ;
44302 PyObject *swig_obj[1] ;
44303
44304 if (!args) SWIG_fail;
44305 swig_obj[0] = args;
44306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44307 if (!SWIG_IsOK(res1)) {
44308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44309 }
44310 arg1 = reinterpret_cast< wxMenu * >(argp1);
44311 {
44312 PyThreadState* __tstate = wxPyBeginAllowThreads();
44313 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44314 wxPyEndAllowThreads(__tstate);
44315 if (PyErr_Occurred()) SWIG_fail;
44316 }
44317 {
44318 resultobj = wxPyMake_wxObject(result, 0);
44319 }
44320 return resultobj;
44321 fail:
44322 return NULL;
44323 }
44324
44325
44326 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44327 PyObject *obj;
44328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44329 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44330 return SWIG_Py_Void();
44331 }
44332
44333 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44334 return SWIG_Python_InitShadowInstance(args);
44335 }
44336
44337 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44338 PyObject *resultobj = 0;
44339 long arg1 = (long) 0 ;
44340 wxMenuBar *result = 0 ;
44341 long val1 ;
44342 int ecode1 = 0 ;
44343 PyObject * obj0 = 0 ;
44344 char * kwnames[] = {
44345 (char *) "style", NULL
44346 };
44347
44348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44349 if (obj0) {
44350 ecode1 = SWIG_AsVal_long(obj0, &val1);
44351 if (!SWIG_IsOK(ecode1)) {
44352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44353 }
44354 arg1 = static_cast< long >(val1);
44355 }
44356 {
44357 if (!wxPyCheckForApp()) SWIG_fail;
44358 PyThreadState* __tstate = wxPyBeginAllowThreads();
44359 result = (wxMenuBar *)new wxMenuBar(arg1);
44360 wxPyEndAllowThreads(__tstate);
44361 if (PyErr_Occurred()) SWIG_fail;
44362 }
44363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44364 return resultobj;
44365 fail:
44366 return NULL;
44367 }
44368
44369
44370 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44371 PyObject *resultobj = 0;
44372 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44373 wxMenu *arg2 = (wxMenu *) 0 ;
44374 wxString *arg3 = 0 ;
44375 bool result;
44376 void *argp1 = 0 ;
44377 int res1 = 0 ;
44378 void *argp2 = 0 ;
44379 int res2 = 0 ;
44380 bool temp3 = false ;
44381 PyObject * obj0 = 0 ;
44382 PyObject * obj1 = 0 ;
44383 PyObject * obj2 = 0 ;
44384 char * kwnames[] = {
44385 (char *) "self",(char *) "menu",(char *) "title", NULL
44386 };
44387
44388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44390 if (!SWIG_IsOK(res1)) {
44391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44392 }
44393 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44395 if (!SWIG_IsOK(res2)) {
44396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44397 }
44398 arg2 = reinterpret_cast< wxMenu * >(argp2);
44399 {
44400 arg3 = wxString_in_helper(obj2);
44401 if (arg3 == NULL) SWIG_fail;
44402 temp3 = true;
44403 }
44404 {
44405 PyThreadState* __tstate = wxPyBeginAllowThreads();
44406 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44407 wxPyEndAllowThreads(__tstate);
44408 if (PyErr_Occurred()) SWIG_fail;
44409 }
44410 {
44411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44412 }
44413 {
44414 if (temp3)
44415 delete arg3;
44416 }
44417 return resultobj;
44418 fail:
44419 {
44420 if (temp3)
44421 delete arg3;
44422 }
44423 return NULL;
44424 }
44425
44426
44427 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44428 PyObject *resultobj = 0;
44429 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44430 size_t arg2 ;
44431 wxMenu *arg3 = (wxMenu *) 0 ;
44432 wxString *arg4 = 0 ;
44433 bool result;
44434 void *argp1 = 0 ;
44435 int res1 = 0 ;
44436 size_t val2 ;
44437 int ecode2 = 0 ;
44438 void *argp3 = 0 ;
44439 int res3 = 0 ;
44440 bool temp4 = false ;
44441 PyObject * obj0 = 0 ;
44442 PyObject * obj1 = 0 ;
44443 PyObject * obj2 = 0 ;
44444 PyObject * obj3 = 0 ;
44445 char * kwnames[] = {
44446 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44447 };
44448
44449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44451 if (!SWIG_IsOK(res1)) {
44452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44453 }
44454 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44455 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44456 if (!SWIG_IsOK(ecode2)) {
44457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44458 }
44459 arg2 = static_cast< size_t >(val2);
44460 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44461 if (!SWIG_IsOK(res3)) {
44462 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44463 }
44464 arg3 = reinterpret_cast< wxMenu * >(argp3);
44465 {
44466 arg4 = wxString_in_helper(obj3);
44467 if (arg4 == NULL) SWIG_fail;
44468 temp4 = true;
44469 }
44470 {
44471 PyThreadState* __tstate = wxPyBeginAllowThreads();
44472 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44473 wxPyEndAllowThreads(__tstate);
44474 if (PyErr_Occurred()) SWIG_fail;
44475 }
44476 {
44477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44478 }
44479 {
44480 if (temp4)
44481 delete arg4;
44482 }
44483 return resultobj;
44484 fail:
44485 {
44486 if (temp4)
44487 delete arg4;
44488 }
44489 return NULL;
44490 }
44491
44492
44493 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44494 PyObject *resultobj = 0;
44495 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44496 size_t result;
44497 void *argp1 = 0 ;
44498 int res1 = 0 ;
44499 PyObject *swig_obj[1] ;
44500
44501 if (!args) SWIG_fail;
44502 swig_obj[0] = args;
44503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44504 if (!SWIG_IsOK(res1)) {
44505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44506 }
44507 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44508 {
44509 PyThreadState* __tstate = wxPyBeginAllowThreads();
44510 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44511 wxPyEndAllowThreads(__tstate);
44512 if (PyErr_Occurred()) SWIG_fail;
44513 }
44514 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44515 return resultobj;
44516 fail:
44517 return NULL;
44518 }
44519
44520
44521 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44522 PyObject *resultobj = 0;
44523 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44524 size_t arg2 ;
44525 wxMenu *result = 0 ;
44526 void *argp1 = 0 ;
44527 int res1 = 0 ;
44528 size_t val2 ;
44529 int ecode2 = 0 ;
44530 PyObject * obj0 = 0 ;
44531 PyObject * obj1 = 0 ;
44532 char * kwnames[] = {
44533 (char *) "self",(char *) "pos", NULL
44534 };
44535
44536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44538 if (!SWIG_IsOK(res1)) {
44539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44540 }
44541 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44542 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44543 if (!SWIG_IsOK(ecode2)) {
44544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44545 }
44546 arg2 = static_cast< size_t >(val2);
44547 {
44548 PyThreadState* __tstate = wxPyBeginAllowThreads();
44549 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44550 wxPyEndAllowThreads(__tstate);
44551 if (PyErr_Occurred()) SWIG_fail;
44552 }
44553 {
44554 resultobj = wxPyMake_wxObject(result, 0);
44555 }
44556 return resultobj;
44557 fail:
44558 return NULL;
44559 }
44560
44561
44562 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44563 PyObject *resultobj = 0;
44564 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44565 size_t arg2 ;
44566 wxMenu *arg3 = (wxMenu *) 0 ;
44567 wxString *arg4 = 0 ;
44568 wxMenu *result = 0 ;
44569 void *argp1 = 0 ;
44570 int res1 = 0 ;
44571 size_t val2 ;
44572 int ecode2 = 0 ;
44573 void *argp3 = 0 ;
44574 int res3 = 0 ;
44575 bool temp4 = false ;
44576 PyObject * obj0 = 0 ;
44577 PyObject * obj1 = 0 ;
44578 PyObject * obj2 = 0 ;
44579 PyObject * obj3 = 0 ;
44580 char * kwnames[] = {
44581 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44582 };
44583
44584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44586 if (!SWIG_IsOK(res1)) {
44587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44588 }
44589 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44590 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44591 if (!SWIG_IsOK(ecode2)) {
44592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44593 }
44594 arg2 = static_cast< size_t >(val2);
44595 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44596 if (!SWIG_IsOK(res3)) {
44597 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44598 }
44599 arg3 = reinterpret_cast< wxMenu * >(argp3);
44600 {
44601 arg4 = wxString_in_helper(obj3);
44602 if (arg4 == NULL) SWIG_fail;
44603 temp4 = true;
44604 }
44605 {
44606 PyThreadState* __tstate = wxPyBeginAllowThreads();
44607 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44608 wxPyEndAllowThreads(__tstate);
44609 if (PyErr_Occurred()) SWIG_fail;
44610 }
44611 {
44612 resultobj = wxPyMake_wxObject(result, 0);
44613 }
44614 {
44615 if (temp4)
44616 delete arg4;
44617 }
44618 return resultobj;
44619 fail:
44620 {
44621 if (temp4)
44622 delete arg4;
44623 }
44624 return NULL;
44625 }
44626
44627
44628 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44629 PyObject *resultobj = 0;
44630 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44631 size_t arg2 ;
44632 wxMenu *result = 0 ;
44633 void *argp1 = 0 ;
44634 int res1 = 0 ;
44635 size_t val2 ;
44636 int ecode2 = 0 ;
44637 PyObject * obj0 = 0 ;
44638 PyObject * obj1 = 0 ;
44639 char * kwnames[] = {
44640 (char *) "self",(char *) "pos", NULL
44641 };
44642
44643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44645 if (!SWIG_IsOK(res1)) {
44646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44647 }
44648 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44649 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44650 if (!SWIG_IsOK(ecode2)) {
44651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44652 }
44653 arg2 = static_cast< size_t >(val2);
44654 {
44655 PyThreadState* __tstate = wxPyBeginAllowThreads();
44656 result = (wxMenu *)(arg1)->Remove(arg2);
44657 wxPyEndAllowThreads(__tstate);
44658 if (PyErr_Occurred()) SWIG_fail;
44659 }
44660 {
44661 resultobj = wxPyMake_wxObject(result, 0);
44662 }
44663 return resultobj;
44664 fail:
44665 return NULL;
44666 }
44667
44668
44669 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44670 PyObject *resultobj = 0;
44671 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44672 size_t arg2 ;
44673 bool arg3 ;
44674 void *argp1 = 0 ;
44675 int res1 = 0 ;
44676 size_t val2 ;
44677 int ecode2 = 0 ;
44678 bool val3 ;
44679 int ecode3 = 0 ;
44680 PyObject * obj0 = 0 ;
44681 PyObject * obj1 = 0 ;
44682 PyObject * obj2 = 0 ;
44683 char * kwnames[] = {
44684 (char *) "self",(char *) "pos",(char *) "enable", NULL
44685 };
44686
44687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44689 if (!SWIG_IsOK(res1)) {
44690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44691 }
44692 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44693 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44694 if (!SWIG_IsOK(ecode2)) {
44695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44696 }
44697 arg2 = static_cast< size_t >(val2);
44698 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44699 if (!SWIG_IsOK(ecode3)) {
44700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44701 }
44702 arg3 = static_cast< bool >(val3);
44703 {
44704 PyThreadState* __tstate = wxPyBeginAllowThreads();
44705 (arg1)->EnableTop(arg2,arg3);
44706 wxPyEndAllowThreads(__tstate);
44707 if (PyErr_Occurred()) SWIG_fail;
44708 }
44709 resultobj = SWIG_Py_Void();
44710 return resultobj;
44711 fail:
44712 return NULL;
44713 }
44714
44715
44716 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44717 PyObject *resultobj = 0;
44718 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44719 size_t arg2 ;
44720 bool result;
44721 void *argp1 = 0 ;
44722 int res1 = 0 ;
44723 size_t val2 ;
44724 int ecode2 = 0 ;
44725 PyObject * obj0 = 0 ;
44726 PyObject * obj1 = 0 ;
44727 char * kwnames[] = {
44728 (char *) "self",(char *) "pos", NULL
44729 };
44730
44731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44733 if (!SWIG_IsOK(res1)) {
44734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44735 }
44736 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44737 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44738 if (!SWIG_IsOK(ecode2)) {
44739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44740 }
44741 arg2 = static_cast< size_t >(val2);
44742 {
44743 PyThreadState* __tstate = wxPyBeginAllowThreads();
44744 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44745 wxPyEndAllowThreads(__tstate);
44746 if (PyErr_Occurred()) SWIG_fail;
44747 }
44748 {
44749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44750 }
44751 return resultobj;
44752 fail:
44753 return NULL;
44754 }
44755
44756
44757 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44758 PyObject *resultobj = 0;
44759 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44760 size_t arg2 ;
44761 wxString *arg3 = 0 ;
44762 void *argp1 = 0 ;
44763 int res1 = 0 ;
44764 size_t val2 ;
44765 int ecode2 = 0 ;
44766 bool temp3 = false ;
44767 PyObject * obj0 = 0 ;
44768 PyObject * obj1 = 0 ;
44769 PyObject * obj2 = 0 ;
44770 char * kwnames[] = {
44771 (char *) "self",(char *) "pos",(char *) "label", NULL
44772 };
44773
44774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44776 if (!SWIG_IsOK(res1)) {
44777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44778 }
44779 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44780 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44781 if (!SWIG_IsOK(ecode2)) {
44782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44783 }
44784 arg2 = static_cast< size_t >(val2);
44785 {
44786 arg3 = wxString_in_helper(obj2);
44787 if (arg3 == NULL) SWIG_fail;
44788 temp3 = true;
44789 }
44790 {
44791 PyThreadState* __tstate = wxPyBeginAllowThreads();
44792 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44793 wxPyEndAllowThreads(__tstate);
44794 if (PyErr_Occurred()) SWIG_fail;
44795 }
44796 resultobj = SWIG_Py_Void();
44797 {
44798 if (temp3)
44799 delete arg3;
44800 }
44801 return resultobj;
44802 fail:
44803 {
44804 if (temp3)
44805 delete arg3;
44806 }
44807 return NULL;
44808 }
44809
44810
44811 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44812 PyObject *resultobj = 0;
44813 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44814 size_t arg2 ;
44815 wxString result;
44816 void *argp1 = 0 ;
44817 int res1 = 0 ;
44818 size_t val2 ;
44819 int ecode2 = 0 ;
44820 PyObject * obj0 = 0 ;
44821 PyObject * obj1 = 0 ;
44822 char * kwnames[] = {
44823 (char *) "self",(char *) "pos", NULL
44824 };
44825
44826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44828 if (!SWIG_IsOK(res1)) {
44829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44830 }
44831 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44832 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44833 if (!SWIG_IsOK(ecode2)) {
44834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44835 }
44836 arg2 = static_cast< size_t >(val2);
44837 {
44838 PyThreadState* __tstate = wxPyBeginAllowThreads();
44839 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44840 wxPyEndAllowThreads(__tstate);
44841 if (PyErr_Occurred()) SWIG_fail;
44842 }
44843 {
44844 #if wxUSE_UNICODE
44845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44846 #else
44847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44848 #endif
44849 }
44850 return resultobj;
44851 fail:
44852 return NULL;
44853 }
44854
44855
44856 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44857 PyObject *resultobj = 0;
44858 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44859 wxString *arg2 = 0 ;
44860 wxString *arg3 = 0 ;
44861 int result;
44862 void *argp1 = 0 ;
44863 int res1 = 0 ;
44864 bool temp2 = false ;
44865 bool temp3 = false ;
44866 PyObject * obj0 = 0 ;
44867 PyObject * obj1 = 0 ;
44868 PyObject * obj2 = 0 ;
44869 char * kwnames[] = {
44870 (char *) "self",(char *) "menu",(char *) "item", NULL
44871 };
44872
44873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44875 if (!SWIG_IsOK(res1)) {
44876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44877 }
44878 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44879 {
44880 arg2 = wxString_in_helper(obj1);
44881 if (arg2 == NULL) SWIG_fail;
44882 temp2 = true;
44883 }
44884 {
44885 arg3 = wxString_in_helper(obj2);
44886 if (arg3 == NULL) SWIG_fail;
44887 temp3 = true;
44888 }
44889 {
44890 PyThreadState* __tstate = wxPyBeginAllowThreads();
44891 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44892 wxPyEndAllowThreads(__tstate);
44893 if (PyErr_Occurred()) SWIG_fail;
44894 }
44895 resultobj = SWIG_From_int(static_cast< int >(result));
44896 {
44897 if (temp2)
44898 delete arg2;
44899 }
44900 {
44901 if (temp3)
44902 delete arg3;
44903 }
44904 return resultobj;
44905 fail:
44906 {
44907 if (temp2)
44908 delete arg2;
44909 }
44910 {
44911 if (temp3)
44912 delete arg3;
44913 }
44914 return NULL;
44915 }
44916
44917
44918 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44919 PyObject *resultobj = 0;
44920 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44921 int arg2 ;
44922 wxMenuItem *result = 0 ;
44923 void *argp1 = 0 ;
44924 int res1 = 0 ;
44925 int val2 ;
44926 int ecode2 = 0 ;
44927 PyObject * obj0 = 0 ;
44928 PyObject * obj1 = 0 ;
44929 char * kwnames[] = {
44930 (char *) "self",(char *) "id", NULL
44931 };
44932
44933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44935 if (!SWIG_IsOK(res1)) {
44936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44937 }
44938 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44939 ecode2 = SWIG_AsVal_int(obj1, &val2);
44940 if (!SWIG_IsOK(ecode2)) {
44941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44942 }
44943 arg2 = static_cast< int >(val2);
44944 {
44945 PyThreadState* __tstate = wxPyBeginAllowThreads();
44946 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44947 wxPyEndAllowThreads(__tstate);
44948 if (PyErr_Occurred()) SWIG_fail;
44949 }
44950 {
44951 resultobj = wxPyMake_wxObject(result, (bool)0);
44952 }
44953 return resultobj;
44954 fail:
44955 return NULL;
44956 }
44957
44958
44959 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44960 PyObject *resultobj = 0;
44961 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44962 wxString *arg2 = 0 ;
44963 int result;
44964 void *argp1 = 0 ;
44965 int res1 = 0 ;
44966 bool temp2 = false ;
44967 PyObject * obj0 = 0 ;
44968 PyObject * obj1 = 0 ;
44969 char * kwnames[] = {
44970 (char *) "self",(char *) "title", NULL
44971 };
44972
44973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44975 if (!SWIG_IsOK(res1)) {
44976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44977 }
44978 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44979 {
44980 arg2 = wxString_in_helper(obj1);
44981 if (arg2 == NULL) SWIG_fail;
44982 temp2 = true;
44983 }
44984 {
44985 PyThreadState* __tstate = wxPyBeginAllowThreads();
44986 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
44987 wxPyEndAllowThreads(__tstate);
44988 if (PyErr_Occurred()) SWIG_fail;
44989 }
44990 resultobj = SWIG_From_int(static_cast< int >(result));
44991 {
44992 if (temp2)
44993 delete arg2;
44994 }
44995 return resultobj;
44996 fail:
44997 {
44998 if (temp2)
44999 delete arg2;
45000 }
45001 return NULL;
45002 }
45003
45004
45005 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45006 PyObject *resultobj = 0;
45007 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45008 int arg2 ;
45009 bool arg3 ;
45010 void *argp1 = 0 ;
45011 int res1 = 0 ;
45012 int val2 ;
45013 int ecode2 = 0 ;
45014 bool val3 ;
45015 int ecode3 = 0 ;
45016 PyObject * obj0 = 0 ;
45017 PyObject * obj1 = 0 ;
45018 PyObject * obj2 = 0 ;
45019 char * kwnames[] = {
45020 (char *) "self",(char *) "id",(char *) "enable", NULL
45021 };
45022
45023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45025 if (!SWIG_IsOK(res1)) {
45026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45027 }
45028 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45029 ecode2 = SWIG_AsVal_int(obj1, &val2);
45030 if (!SWIG_IsOK(ecode2)) {
45031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45032 }
45033 arg2 = static_cast< int >(val2);
45034 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45035 if (!SWIG_IsOK(ecode3)) {
45036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45037 }
45038 arg3 = static_cast< bool >(val3);
45039 {
45040 PyThreadState* __tstate = wxPyBeginAllowThreads();
45041 (arg1)->Enable(arg2,arg3);
45042 wxPyEndAllowThreads(__tstate);
45043 if (PyErr_Occurred()) SWIG_fail;
45044 }
45045 resultobj = SWIG_Py_Void();
45046 return resultobj;
45047 fail:
45048 return NULL;
45049 }
45050
45051
45052 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45053 PyObject *resultobj = 0;
45054 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45055 int arg2 ;
45056 bool arg3 ;
45057 void *argp1 = 0 ;
45058 int res1 = 0 ;
45059 int val2 ;
45060 int ecode2 = 0 ;
45061 bool val3 ;
45062 int ecode3 = 0 ;
45063 PyObject * obj0 = 0 ;
45064 PyObject * obj1 = 0 ;
45065 PyObject * obj2 = 0 ;
45066 char * kwnames[] = {
45067 (char *) "self",(char *) "id",(char *) "check", NULL
45068 };
45069
45070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45072 if (!SWIG_IsOK(res1)) {
45073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45074 }
45075 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45076 ecode2 = SWIG_AsVal_int(obj1, &val2);
45077 if (!SWIG_IsOK(ecode2)) {
45078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45079 }
45080 arg2 = static_cast< int >(val2);
45081 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45082 if (!SWIG_IsOK(ecode3)) {
45083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45084 }
45085 arg3 = static_cast< bool >(val3);
45086 {
45087 PyThreadState* __tstate = wxPyBeginAllowThreads();
45088 (arg1)->Check(arg2,arg3);
45089 wxPyEndAllowThreads(__tstate);
45090 if (PyErr_Occurred()) SWIG_fail;
45091 }
45092 resultobj = SWIG_Py_Void();
45093 return resultobj;
45094 fail:
45095 return NULL;
45096 }
45097
45098
45099 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45100 PyObject *resultobj = 0;
45101 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45102 int arg2 ;
45103 bool result;
45104 void *argp1 = 0 ;
45105 int res1 = 0 ;
45106 int val2 ;
45107 int ecode2 = 0 ;
45108 PyObject * obj0 = 0 ;
45109 PyObject * obj1 = 0 ;
45110 char * kwnames[] = {
45111 (char *) "self",(char *) "id", NULL
45112 };
45113
45114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45116 if (!SWIG_IsOK(res1)) {
45117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45118 }
45119 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45120 ecode2 = SWIG_AsVal_int(obj1, &val2);
45121 if (!SWIG_IsOK(ecode2)) {
45122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45123 }
45124 arg2 = static_cast< int >(val2);
45125 {
45126 PyThreadState* __tstate = wxPyBeginAllowThreads();
45127 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45128 wxPyEndAllowThreads(__tstate);
45129 if (PyErr_Occurred()) SWIG_fail;
45130 }
45131 {
45132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45133 }
45134 return resultobj;
45135 fail:
45136 return NULL;
45137 }
45138
45139
45140 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45141 PyObject *resultobj = 0;
45142 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45143 int arg2 ;
45144 bool result;
45145 void *argp1 = 0 ;
45146 int res1 = 0 ;
45147 int val2 ;
45148 int ecode2 = 0 ;
45149 PyObject * obj0 = 0 ;
45150 PyObject * obj1 = 0 ;
45151 char * kwnames[] = {
45152 (char *) "self",(char *) "id", NULL
45153 };
45154
45155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45157 if (!SWIG_IsOK(res1)) {
45158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45159 }
45160 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45161 ecode2 = SWIG_AsVal_int(obj1, &val2);
45162 if (!SWIG_IsOK(ecode2)) {
45163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45164 }
45165 arg2 = static_cast< int >(val2);
45166 {
45167 PyThreadState* __tstate = wxPyBeginAllowThreads();
45168 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45169 wxPyEndAllowThreads(__tstate);
45170 if (PyErr_Occurred()) SWIG_fail;
45171 }
45172 {
45173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45174 }
45175 return resultobj;
45176 fail:
45177 return NULL;
45178 }
45179
45180
45181 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45182 PyObject *resultobj = 0;
45183 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45184 int arg2 ;
45185 wxString *arg3 = 0 ;
45186 void *argp1 = 0 ;
45187 int res1 = 0 ;
45188 int val2 ;
45189 int ecode2 = 0 ;
45190 bool temp3 = false ;
45191 PyObject * obj0 = 0 ;
45192 PyObject * obj1 = 0 ;
45193 PyObject * obj2 = 0 ;
45194 char * kwnames[] = {
45195 (char *) "self",(char *) "id",(char *) "label", NULL
45196 };
45197
45198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45200 if (!SWIG_IsOK(res1)) {
45201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45202 }
45203 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45204 ecode2 = SWIG_AsVal_int(obj1, &val2);
45205 if (!SWIG_IsOK(ecode2)) {
45206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45207 }
45208 arg2 = static_cast< int >(val2);
45209 {
45210 arg3 = wxString_in_helper(obj2);
45211 if (arg3 == NULL) SWIG_fail;
45212 temp3 = true;
45213 }
45214 {
45215 PyThreadState* __tstate = wxPyBeginAllowThreads();
45216 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45217 wxPyEndAllowThreads(__tstate);
45218 if (PyErr_Occurred()) SWIG_fail;
45219 }
45220 resultobj = SWIG_Py_Void();
45221 {
45222 if (temp3)
45223 delete arg3;
45224 }
45225 return resultobj;
45226 fail:
45227 {
45228 if (temp3)
45229 delete arg3;
45230 }
45231 return NULL;
45232 }
45233
45234
45235 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45236 PyObject *resultobj = 0;
45237 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45238 int arg2 ;
45239 wxString result;
45240 void *argp1 = 0 ;
45241 int res1 = 0 ;
45242 int val2 ;
45243 int ecode2 = 0 ;
45244 PyObject * obj0 = 0 ;
45245 PyObject * obj1 = 0 ;
45246 char * kwnames[] = {
45247 (char *) "self",(char *) "id", NULL
45248 };
45249
45250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45252 if (!SWIG_IsOK(res1)) {
45253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45254 }
45255 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45256 ecode2 = SWIG_AsVal_int(obj1, &val2);
45257 if (!SWIG_IsOK(ecode2)) {
45258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45259 }
45260 arg2 = static_cast< int >(val2);
45261 {
45262 PyThreadState* __tstate = wxPyBeginAllowThreads();
45263 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45264 wxPyEndAllowThreads(__tstate);
45265 if (PyErr_Occurred()) SWIG_fail;
45266 }
45267 {
45268 #if wxUSE_UNICODE
45269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45270 #else
45271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45272 #endif
45273 }
45274 return resultobj;
45275 fail:
45276 return NULL;
45277 }
45278
45279
45280 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45281 PyObject *resultobj = 0;
45282 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45283 int arg2 ;
45284 wxString *arg3 = 0 ;
45285 void *argp1 = 0 ;
45286 int res1 = 0 ;
45287 int val2 ;
45288 int ecode2 = 0 ;
45289 bool temp3 = false ;
45290 PyObject * obj0 = 0 ;
45291 PyObject * obj1 = 0 ;
45292 PyObject * obj2 = 0 ;
45293 char * kwnames[] = {
45294 (char *) "self",(char *) "id",(char *) "helpString", NULL
45295 };
45296
45297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45299 if (!SWIG_IsOK(res1)) {
45300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45301 }
45302 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45303 ecode2 = SWIG_AsVal_int(obj1, &val2);
45304 if (!SWIG_IsOK(ecode2)) {
45305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45306 }
45307 arg2 = static_cast< int >(val2);
45308 {
45309 arg3 = wxString_in_helper(obj2);
45310 if (arg3 == NULL) SWIG_fail;
45311 temp3 = true;
45312 }
45313 {
45314 PyThreadState* __tstate = wxPyBeginAllowThreads();
45315 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45316 wxPyEndAllowThreads(__tstate);
45317 if (PyErr_Occurred()) SWIG_fail;
45318 }
45319 resultobj = SWIG_Py_Void();
45320 {
45321 if (temp3)
45322 delete arg3;
45323 }
45324 return resultobj;
45325 fail:
45326 {
45327 if (temp3)
45328 delete arg3;
45329 }
45330 return NULL;
45331 }
45332
45333
45334 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45335 PyObject *resultobj = 0;
45336 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45337 int arg2 ;
45338 wxString result;
45339 void *argp1 = 0 ;
45340 int res1 = 0 ;
45341 int val2 ;
45342 int ecode2 = 0 ;
45343 PyObject * obj0 = 0 ;
45344 PyObject * obj1 = 0 ;
45345 char * kwnames[] = {
45346 (char *) "self",(char *) "id", NULL
45347 };
45348
45349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45351 if (!SWIG_IsOK(res1)) {
45352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45353 }
45354 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45355 ecode2 = SWIG_AsVal_int(obj1, &val2);
45356 if (!SWIG_IsOK(ecode2)) {
45357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45358 }
45359 arg2 = static_cast< int >(val2);
45360 {
45361 PyThreadState* __tstate = wxPyBeginAllowThreads();
45362 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45363 wxPyEndAllowThreads(__tstate);
45364 if (PyErr_Occurred()) SWIG_fail;
45365 }
45366 {
45367 #if wxUSE_UNICODE
45368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45369 #else
45370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45371 #endif
45372 }
45373 return resultobj;
45374 fail:
45375 return NULL;
45376 }
45377
45378
45379 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45380 PyObject *resultobj = 0;
45381 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45382 wxFrame *result = 0 ;
45383 void *argp1 = 0 ;
45384 int res1 = 0 ;
45385 PyObject *swig_obj[1] ;
45386
45387 if (!args) SWIG_fail;
45388 swig_obj[0] = args;
45389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45390 if (!SWIG_IsOK(res1)) {
45391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45392 }
45393 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45394 {
45395 PyThreadState* __tstate = wxPyBeginAllowThreads();
45396 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45397 wxPyEndAllowThreads(__tstate);
45398 if (PyErr_Occurred()) SWIG_fail;
45399 }
45400 {
45401 resultobj = wxPyMake_wxObject(result, (bool)0);
45402 }
45403 return resultobj;
45404 fail:
45405 return NULL;
45406 }
45407
45408
45409 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45410 PyObject *resultobj = 0;
45411 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45412 bool result;
45413 void *argp1 = 0 ;
45414 int res1 = 0 ;
45415 PyObject *swig_obj[1] ;
45416
45417 if (!args) SWIG_fail;
45418 swig_obj[0] = args;
45419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45420 if (!SWIG_IsOK(res1)) {
45421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45422 }
45423 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45424 {
45425 PyThreadState* __tstate = wxPyBeginAllowThreads();
45426 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45427 wxPyEndAllowThreads(__tstate);
45428 if (PyErr_Occurred()) SWIG_fail;
45429 }
45430 {
45431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45432 }
45433 return resultobj;
45434 fail:
45435 return NULL;
45436 }
45437
45438
45439 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45440 PyObject *resultobj = 0;
45441 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45442 wxFrame *arg2 = (wxFrame *) 0 ;
45443 void *argp1 = 0 ;
45444 int res1 = 0 ;
45445 void *argp2 = 0 ;
45446 int res2 = 0 ;
45447 PyObject * obj0 = 0 ;
45448 PyObject * obj1 = 0 ;
45449 char * kwnames[] = {
45450 (char *) "self",(char *) "frame", NULL
45451 };
45452
45453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45455 if (!SWIG_IsOK(res1)) {
45456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45457 }
45458 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45459 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45460 if (!SWIG_IsOK(res2)) {
45461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45462 }
45463 arg2 = reinterpret_cast< wxFrame * >(argp2);
45464 {
45465 PyThreadState* __tstate = wxPyBeginAllowThreads();
45466 (arg1)->Attach(arg2);
45467 wxPyEndAllowThreads(__tstate);
45468 if (PyErr_Occurred()) SWIG_fail;
45469 }
45470 resultobj = SWIG_Py_Void();
45471 return resultobj;
45472 fail:
45473 return NULL;
45474 }
45475
45476
45477 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45478 PyObject *resultobj = 0;
45479 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45480 void *argp1 = 0 ;
45481 int res1 = 0 ;
45482 PyObject *swig_obj[1] ;
45483
45484 if (!args) SWIG_fail;
45485 swig_obj[0] = args;
45486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45487 if (!SWIG_IsOK(res1)) {
45488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45489 }
45490 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45491 {
45492 PyThreadState* __tstate = wxPyBeginAllowThreads();
45493 (arg1)->Detach();
45494 wxPyEndAllowThreads(__tstate);
45495 if (PyErr_Occurred()) SWIG_fail;
45496 }
45497 resultobj = SWIG_Py_Void();
45498 return resultobj;
45499 fail:
45500 return NULL;
45501 }
45502
45503
45504 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45505 PyObject *resultobj = 0;
45506 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45507 void *argp1 = 0 ;
45508 int res1 = 0 ;
45509 PyObject *swig_obj[1] ;
45510
45511 if (!args) SWIG_fail;
45512 swig_obj[0] = args;
45513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45514 if (!SWIG_IsOK(res1)) {
45515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45516 }
45517 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45518 {
45519 PyThreadState* __tstate = wxPyBeginAllowThreads();
45520 (arg1)->UpdateMenus();
45521 wxPyEndAllowThreads(__tstate);
45522 if (PyErr_Occurred()) SWIG_fail;
45523 }
45524 resultobj = SWIG_Py_Void();
45525 return resultobj;
45526 fail:
45527 return NULL;
45528 }
45529
45530
45531 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45532 PyObject *resultobj = 0;
45533 bool arg1 ;
45534 bool val1 ;
45535 int ecode1 = 0 ;
45536 PyObject * obj0 = 0 ;
45537 char * kwnames[] = {
45538 (char *) "enable", NULL
45539 };
45540
45541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45542 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45543 if (!SWIG_IsOK(ecode1)) {
45544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45545 }
45546 arg1 = static_cast< bool >(val1);
45547 {
45548 PyThreadState* __tstate = wxPyBeginAllowThreads();
45549 wxMenuBar_SetAutoWindowMenu(arg1);
45550 wxPyEndAllowThreads(__tstate);
45551 if (PyErr_Occurred()) SWIG_fail;
45552 }
45553 resultobj = SWIG_Py_Void();
45554 return resultobj;
45555 fail:
45556 return NULL;
45557 }
45558
45559
45560 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45561 PyObject *resultobj = 0;
45562 bool result;
45563
45564 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45565 {
45566 PyThreadState* __tstate = wxPyBeginAllowThreads();
45567 result = (bool)wxMenuBar_GetAutoWindowMenu();
45568 wxPyEndAllowThreads(__tstate);
45569 if (PyErr_Occurred()) SWIG_fail;
45570 }
45571 {
45572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45573 }
45574 return resultobj;
45575 fail:
45576 return NULL;
45577 }
45578
45579
45580 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45581 PyObject *obj;
45582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45583 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45584 return SWIG_Py_Void();
45585 }
45586
45587 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45588 return SWIG_Python_InitShadowInstance(args);
45589 }
45590
45591 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45592 PyObject *resultobj = 0;
45593 wxMenu *arg1 = (wxMenu *) NULL ;
45594 int arg2 = (int) wxID_ANY ;
45595 wxString const &arg3_defvalue = wxPyEmptyString ;
45596 wxString *arg3 = (wxString *) &arg3_defvalue ;
45597 wxString const &arg4_defvalue = wxPyEmptyString ;
45598 wxString *arg4 = (wxString *) &arg4_defvalue ;
45599 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45600 wxMenu *arg6 = (wxMenu *) NULL ;
45601 wxMenuItem *result = 0 ;
45602 void *argp1 = 0 ;
45603 int res1 = 0 ;
45604 int val2 ;
45605 int ecode2 = 0 ;
45606 bool temp3 = false ;
45607 bool temp4 = false ;
45608 int val5 ;
45609 int ecode5 = 0 ;
45610 void *argp6 = 0 ;
45611 int res6 = 0 ;
45612 PyObject * obj0 = 0 ;
45613 PyObject * obj1 = 0 ;
45614 PyObject * obj2 = 0 ;
45615 PyObject * obj3 = 0 ;
45616 PyObject * obj4 = 0 ;
45617 PyObject * obj5 = 0 ;
45618 char * kwnames[] = {
45619 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45620 };
45621
45622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45623 if (obj0) {
45624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45625 if (!SWIG_IsOK(res1)) {
45626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45627 }
45628 arg1 = reinterpret_cast< wxMenu * >(argp1);
45629 }
45630 if (obj1) {
45631 ecode2 = SWIG_AsVal_int(obj1, &val2);
45632 if (!SWIG_IsOK(ecode2)) {
45633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45634 }
45635 arg2 = static_cast< int >(val2);
45636 }
45637 if (obj2) {
45638 {
45639 arg3 = wxString_in_helper(obj2);
45640 if (arg3 == NULL) SWIG_fail;
45641 temp3 = true;
45642 }
45643 }
45644 if (obj3) {
45645 {
45646 arg4 = wxString_in_helper(obj3);
45647 if (arg4 == NULL) SWIG_fail;
45648 temp4 = true;
45649 }
45650 }
45651 if (obj4) {
45652 ecode5 = SWIG_AsVal_int(obj4, &val5);
45653 if (!SWIG_IsOK(ecode5)) {
45654 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45655 }
45656 arg5 = static_cast< wxItemKind >(val5);
45657 }
45658 if (obj5) {
45659 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45660 if (!SWIG_IsOK(res6)) {
45661 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45662 }
45663 arg6 = reinterpret_cast< wxMenu * >(argp6);
45664 }
45665 {
45666 PyThreadState* __tstate = wxPyBeginAllowThreads();
45667 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45668 wxPyEndAllowThreads(__tstate);
45669 if (PyErr_Occurred()) SWIG_fail;
45670 }
45671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45672 {
45673 if (temp3)
45674 delete arg3;
45675 }
45676 {
45677 if (temp4)
45678 delete arg4;
45679 }
45680 return resultobj;
45681 fail:
45682 {
45683 if (temp3)
45684 delete arg3;
45685 }
45686 {
45687 if (temp4)
45688 delete arg4;
45689 }
45690 return NULL;
45691 }
45692
45693
45694 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45695 PyObject *resultobj = 0;
45696 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45697 void *argp1 = 0 ;
45698 int res1 = 0 ;
45699 PyObject *swig_obj[1] ;
45700
45701 if (!args) SWIG_fail;
45702 swig_obj[0] = args;
45703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45704 if (!SWIG_IsOK(res1)) {
45705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45706 }
45707 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45708 {
45709 PyThreadState* __tstate = wxPyBeginAllowThreads();
45710 delete arg1;
45711
45712 wxPyEndAllowThreads(__tstate);
45713 if (PyErr_Occurred()) SWIG_fail;
45714 }
45715 resultobj = SWIG_Py_Void();
45716 return resultobj;
45717 fail:
45718 return NULL;
45719 }
45720
45721
45722 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45723 PyObject *resultobj = 0;
45724 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45725 wxMenu *result = 0 ;
45726 void *argp1 = 0 ;
45727 int res1 = 0 ;
45728 PyObject *swig_obj[1] ;
45729
45730 if (!args) SWIG_fail;
45731 swig_obj[0] = args;
45732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45733 if (!SWIG_IsOK(res1)) {
45734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45735 }
45736 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 {
45744 resultobj = wxPyMake_wxObject(result, 0);
45745 }
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = 0;
45754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45755 wxMenu *arg2 = (wxMenu *) 0 ;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 void *argp2 = 0 ;
45759 int res2 = 0 ;
45760 PyObject * obj0 = 0 ;
45761 PyObject * obj1 = 0 ;
45762 char * kwnames[] = {
45763 (char *) "self",(char *) "menu", NULL
45764 };
45765
45766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45768 if (!SWIG_IsOK(res1)) {
45769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45770 }
45771 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45773 if (!SWIG_IsOK(res2)) {
45774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45775 }
45776 arg2 = reinterpret_cast< wxMenu * >(argp2);
45777 {
45778 PyThreadState* __tstate = wxPyBeginAllowThreads();
45779 (arg1)->SetMenu(arg2);
45780 wxPyEndAllowThreads(__tstate);
45781 if (PyErr_Occurred()) SWIG_fail;
45782 }
45783 resultobj = SWIG_Py_Void();
45784 return resultobj;
45785 fail:
45786 return NULL;
45787 }
45788
45789
45790 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45791 PyObject *resultobj = 0;
45792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45793 int arg2 ;
45794 void *argp1 = 0 ;
45795 int res1 = 0 ;
45796 int val2 ;
45797 int ecode2 = 0 ;
45798 PyObject * obj0 = 0 ;
45799 PyObject * obj1 = 0 ;
45800 char * kwnames[] = {
45801 (char *) "self",(char *) "id", NULL
45802 };
45803
45804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45806 if (!SWIG_IsOK(res1)) {
45807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45808 }
45809 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45810 ecode2 = SWIG_AsVal_int(obj1, &val2);
45811 if (!SWIG_IsOK(ecode2)) {
45812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45813 }
45814 arg2 = static_cast< int >(val2);
45815 {
45816 PyThreadState* __tstate = wxPyBeginAllowThreads();
45817 (arg1)->SetId(arg2);
45818 wxPyEndAllowThreads(__tstate);
45819 if (PyErr_Occurred()) SWIG_fail;
45820 }
45821 resultobj = SWIG_Py_Void();
45822 return resultobj;
45823 fail:
45824 return NULL;
45825 }
45826
45827
45828 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45829 PyObject *resultobj = 0;
45830 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45831 int result;
45832 void *argp1 = 0 ;
45833 int res1 = 0 ;
45834 PyObject *swig_obj[1] ;
45835
45836 if (!args) SWIG_fail;
45837 swig_obj[0] = args;
45838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45839 if (!SWIG_IsOK(res1)) {
45840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45841 }
45842 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45843 {
45844 PyThreadState* __tstate = wxPyBeginAllowThreads();
45845 result = (int)((wxMenuItem const *)arg1)->GetId();
45846 wxPyEndAllowThreads(__tstate);
45847 if (PyErr_Occurred()) SWIG_fail;
45848 }
45849 resultobj = SWIG_From_int(static_cast< int >(result));
45850 return resultobj;
45851 fail:
45852 return NULL;
45853 }
45854
45855
45856 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45857 PyObject *resultobj = 0;
45858 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45859 bool result;
45860 void *argp1 = 0 ;
45861 int res1 = 0 ;
45862 PyObject *swig_obj[1] ;
45863
45864 if (!args) SWIG_fail;
45865 swig_obj[0] = args;
45866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45867 if (!SWIG_IsOK(res1)) {
45868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45869 }
45870 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45871 {
45872 PyThreadState* __tstate = wxPyBeginAllowThreads();
45873 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45874 wxPyEndAllowThreads(__tstate);
45875 if (PyErr_Occurred()) SWIG_fail;
45876 }
45877 {
45878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45879 }
45880 return resultobj;
45881 fail:
45882 return NULL;
45883 }
45884
45885
45886 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45887 PyObject *resultobj = 0;
45888 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45889 wxString *arg2 = 0 ;
45890 void *argp1 = 0 ;
45891 int res1 = 0 ;
45892 bool temp2 = false ;
45893 PyObject * obj0 = 0 ;
45894 PyObject * obj1 = 0 ;
45895 char * kwnames[] = {
45896 (char *) "self",(char *) "str", NULL
45897 };
45898
45899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45901 if (!SWIG_IsOK(res1)) {
45902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45903 }
45904 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45905 {
45906 arg2 = wxString_in_helper(obj1);
45907 if (arg2 == NULL) SWIG_fail;
45908 temp2 = true;
45909 }
45910 {
45911 PyThreadState* __tstate = wxPyBeginAllowThreads();
45912 (arg1)->SetText((wxString const &)*arg2);
45913 wxPyEndAllowThreads(__tstate);
45914 if (PyErr_Occurred()) SWIG_fail;
45915 }
45916 resultobj = SWIG_Py_Void();
45917 {
45918 if (temp2)
45919 delete arg2;
45920 }
45921 return resultobj;
45922 fail:
45923 {
45924 if (temp2)
45925 delete arg2;
45926 }
45927 return NULL;
45928 }
45929
45930
45931 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45932 PyObject *resultobj = 0;
45933 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45934 wxString result;
45935 void *argp1 = 0 ;
45936 int res1 = 0 ;
45937 PyObject *swig_obj[1] ;
45938
45939 if (!args) SWIG_fail;
45940 swig_obj[0] = args;
45941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45942 if (!SWIG_IsOK(res1)) {
45943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45944 }
45945 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45946 {
45947 PyThreadState* __tstate = wxPyBeginAllowThreads();
45948 result = ((wxMenuItem const *)arg1)->GetLabel();
45949 wxPyEndAllowThreads(__tstate);
45950 if (PyErr_Occurred()) SWIG_fail;
45951 }
45952 {
45953 #if wxUSE_UNICODE
45954 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45955 #else
45956 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45957 #endif
45958 }
45959 return resultobj;
45960 fail:
45961 return NULL;
45962 }
45963
45964
45965 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45966 PyObject *resultobj = 0;
45967 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45968 wxString *result = 0 ;
45969 void *argp1 = 0 ;
45970 int res1 = 0 ;
45971 PyObject *swig_obj[1] ;
45972
45973 if (!args) SWIG_fail;
45974 swig_obj[0] = args;
45975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45976 if (!SWIG_IsOK(res1)) {
45977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45978 }
45979 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45980 {
45981 PyThreadState* __tstate = wxPyBeginAllowThreads();
45982 {
45983 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
45984 result = (wxString *) &_result_ref;
45985 }
45986 wxPyEndAllowThreads(__tstate);
45987 if (PyErr_Occurred()) SWIG_fail;
45988 }
45989 {
45990 #if wxUSE_UNICODE
45991 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
45992 #else
45993 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
45994 #endif
45995 }
45996 return resultobj;
45997 fail:
45998 return NULL;
45999 }
46000
46001
46002 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46003 PyObject *resultobj = 0;
46004 wxString *arg1 = 0 ;
46005 wxString result;
46006 bool temp1 = false ;
46007 PyObject * obj0 = 0 ;
46008 char * kwnames[] = {
46009 (char *) "text", NULL
46010 };
46011
46012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46013 {
46014 arg1 = wxString_in_helper(obj0);
46015 if (arg1 == NULL) SWIG_fail;
46016 temp1 = true;
46017 }
46018 {
46019 PyThreadState* __tstate = wxPyBeginAllowThreads();
46020 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46021 wxPyEndAllowThreads(__tstate);
46022 if (PyErr_Occurred()) SWIG_fail;
46023 }
46024 {
46025 #if wxUSE_UNICODE
46026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46027 #else
46028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46029 #endif
46030 }
46031 {
46032 if (temp1)
46033 delete arg1;
46034 }
46035 return resultobj;
46036 fail:
46037 {
46038 if (temp1)
46039 delete arg1;
46040 }
46041 return NULL;
46042 }
46043
46044
46045 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46046 PyObject *resultobj = 0;
46047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46048 wxItemKind result;
46049 void *argp1 = 0 ;
46050 int res1 = 0 ;
46051 PyObject *swig_obj[1] ;
46052
46053 if (!args) SWIG_fail;
46054 swig_obj[0] = args;
46055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46056 if (!SWIG_IsOK(res1)) {
46057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46058 }
46059 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46060 {
46061 PyThreadState* __tstate = wxPyBeginAllowThreads();
46062 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46063 wxPyEndAllowThreads(__tstate);
46064 if (PyErr_Occurred()) SWIG_fail;
46065 }
46066 resultobj = SWIG_From_int(static_cast< int >(result));
46067 return resultobj;
46068 fail:
46069 return NULL;
46070 }
46071
46072
46073 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46074 PyObject *resultobj = 0;
46075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46076 wxItemKind arg2 ;
46077 void *argp1 = 0 ;
46078 int res1 = 0 ;
46079 int val2 ;
46080 int ecode2 = 0 ;
46081 PyObject * obj0 = 0 ;
46082 PyObject * obj1 = 0 ;
46083 char * kwnames[] = {
46084 (char *) "self",(char *) "kind", NULL
46085 };
46086
46087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46089 if (!SWIG_IsOK(res1)) {
46090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46091 }
46092 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46093 ecode2 = SWIG_AsVal_int(obj1, &val2);
46094 if (!SWIG_IsOK(ecode2)) {
46095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46096 }
46097 arg2 = static_cast< wxItemKind >(val2);
46098 {
46099 PyThreadState* __tstate = wxPyBeginAllowThreads();
46100 (arg1)->SetKind(arg2);
46101 wxPyEndAllowThreads(__tstate);
46102 if (PyErr_Occurred()) SWIG_fail;
46103 }
46104 resultobj = SWIG_Py_Void();
46105 return resultobj;
46106 fail:
46107 return NULL;
46108 }
46109
46110
46111 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46112 PyObject *resultobj = 0;
46113 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46114 bool arg2 ;
46115 void *argp1 = 0 ;
46116 int res1 = 0 ;
46117 bool val2 ;
46118 int ecode2 = 0 ;
46119 PyObject * obj0 = 0 ;
46120 PyObject * obj1 = 0 ;
46121 char * kwnames[] = {
46122 (char *) "self",(char *) "checkable", NULL
46123 };
46124
46125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46127 if (!SWIG_IsOK(res1)) {
46128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46129 }
46130 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46131 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46132 if (!SWIG_IsOK(ecode2)) {
46133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46134 }
46135 arg2 = static_cast< bool >(val2);
46136 {
46137 PyThreadState* __tstate = wxPyBeginAllowThreads();
46138 (arg1)->SetCheckable(arg2);
46139 wxPyEndAllowThreads(__tstate);
46140 if (PyErr_Occurred()) SWIG_fail;
46141 }
46142 resultobj = SWIG_Py_Void();
46143 return resultobj;
46144 fail:
46145 return NULL;
46146 }
46147
46148
46149 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46150 PyObject *resultobj = 0;
46151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46152 bool result;
46153 void *argp1 = 0 ;
46154 int res1 = 0 ;
46155 PyObject *swig_obj[1] ;
46156
46157 if (!args) SWIG_fail;
46158 swig_obj[0] = args;
46159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46160 if (!SWIG_IsOK(res1)) {
46161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46162 }
46163 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46164 {
46165 PyThreadState* __tstate = wxPyBeginAllowThreads();
46166 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46167 wxPyEndAllowThreads(__tstate);
46168 if (PyErr_Occurred()) SWIG_fail;
46169 }
46170 {
46171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46172 }
46173 return resultobj;
46174 fail:
46175 return NULL;
46176 }
46177
46178
46179 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46180 PyObject *resultobj = 0;
46181 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46182 bool result;
46183 void *argp1 = 0 ;
46184 int res1 = 0 ;
46185 PyObject *swig_obj[1] ;
46186
46187 if (!args) SWIG_fail;
46188 swig_obj[0] = args;
46189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46190 if (!SWIG_IsOK(res1)) {
46191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46192 }
46193 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46194 {
46195 PyThreadState* __tstate = wxPyBeginAllowThreads();
46196 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46197 wxPyEndAllowThreads(__tstate);
46198 if (PyErr_Occurred()) SWIG_fail;
46199 }
46200 {
46201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46202 }
46203 return resultobj;
46204 fail:
46205 return NULL;
46206 }
46207
46208
46209 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46210 PyObject *resultobj = 0;
46211 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46212 wxMenu *arg2 = (wxMenu *) 0 ;
46213 void *argp1 = 0 ;
46214 int res1 = 0 ;
46215 void *argp2 = 0 ;
46216 int res2 = 0 ;
46217 PyObject * obj0 = 0 ;
46218 PyObject * obj1 = 0 ;
46219 char * kwnames[] = {
46220 (char *) "self",(char *) "menu", NULL
46221 };
46222
46223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46225 if (!SWIG_IsOK(res1)) {
46226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46227 }
46228 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46230 if (!SWIG_IsOK(res2)) {
46231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46232 }
46233 arg2 = reinterpret_cast< wxMenu * >(argp2);
46234 {
46235 PyThreadState* __tstate = wxPyBeginAllowThreads();
46236 (arg1)->SetSubMenu(arg2);
46237 wxPyEndAllowThreads(__tstate);
46238 if (PyErr_Occurred()) SWIG_fail;
46239 }
46240 resultobj = SWIG_Py_Void();
46241 return resultobj;
46242 fail:
46243 return NULL;
46244 }
46245
46246
46247 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46248 PyObject *resultobj = 0;
46249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46250 wxMenu *result = 0 ;
46251 void *argp1 = 0 ;
46252 int res1 = 0 ;
46253 PyObject *swig_obj[1] ;
46254
46255 if (!args) SWIG_fail;
46256 swig_obj[0] = args;
46257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46258 if (!SWIG_IsOK(res1)) {
46259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46260 }
46261 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46262 {
46263 PyThreadState* __tstate = wxPyBeginAllowThreads();
46264 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46265 wxPyEndAllowThreads(__tstate);
46266 if (PyErr_Occurred()) SWIG_fail;
46267 }
46268 {
46269 resultobj = wxPyMake_wxObject(result, 0);
46270 }
46271 return resultobj;
46272 fail:
46273 return NULL;
46274 }
46275
46276
46277 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46278 PyObject *resultobj = 0;
46279 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46280 bool arg2 = (bool) true ;
46281 void *argp1 = 0 ;
46282 int res1 = 0 ;
46283 bool val2 ;
46284 int ecode2 = 0 ;
46285 PyObject * obj0 = 0 ;
46286 PyObject * obj1 = 0 ;
46287 char * kwnames[] = {
46288 (char *) "self",(char *) "enable", NULL
46289 };
46290
46291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46293 if (!SWIG_IsOK(res1)) {
46294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46295 }
46296 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46297 if (obj1) {
46298 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46299 if (!SWIG_IsOK(ecode2)) {
46300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46301 }
46302 arg2 = static_cast< bool >(val2);
46303 }
46304 {
46305 PyThreadState* __tstate = wxPyBeginAllowThreads();
46306 (arg1)->Enable(arg2);
46307 wxPyEndAllowThreads(__tstate);
46308 if (PyErr_Occurred()) SWIG_fail;
46309 }
46310 resultobj = SWIG_Py_Void();
46311 return resultobj;
46312 fail:
46313 return NULL;
46314 }
46315
46316
46317 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46318 PyObject *resultobj = 0;
46319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46320 bool result;
46321 void *argp1 = 0 ;
46322 int res1 = 0 ;
46323 PyObject *swig_obj[1] ;
46324
46325 if (!args) SWIG_fail;
46326 swig_obj[0] = args;
46327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46328 if (!SWIG_IsOK(res1)) {
46329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46330 }
46331 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46332 {
46333 PyThreadState* __tstate = wxPyBeginAllowThreads();
46334 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46335 wxPyEndAllowThreads(__tstate);
46336 if (PyErr_Occurred()) SWIG_fail;
46337 }
46338 {
46339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46340 }
46341 return resultobj;
46342 fail:
46343 return NULL;
46344 }
46345
46346
46347 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46348 PyObject *resultobj = 0;
46349 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46350 bool arg2 = (bool) true ;
46351 void *argp1 = 0 ;
46352 int res1 = 0 ;
46353 bool val2 ;
46354 int ecode2 = 0 ;
46355 PyObject * obj0 = 0 ;
46356 PyObject * obj1 = 0 ;
46357 char * kwnames[] = {
46358 (char *) "self",(char *) "check", NULL
46359 };
46360
46361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46363 if (!SWIG_IsOK(res1)) {
46364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46365 }
46366 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46367 if (obj1) {
46368 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46369 if (!SWIG_IsOK(ecode2)) {
46370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46371 }
46372 arg2 = static_cast< bool >(val2);
46373 }
46374 {
46375 PyThreadState* __tstate = wxPyBeginAllowThreads();
46376 (arg1)->Check(arg2);
46377 wxPyEndAllowThreads(__tstate);
46378 if (PyErr_Occurred()) SWIG_fail;
46379 }
46380 resultobj = SWIG_Py_Void();
46381 return resultobj;
46382 fail:
46383 return NULL;
46384 }
46385
46386
46387 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46388 PyObject *resultobj = 0;
46389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46390 bool result;
46391 void *argp1 = 0 ;
46392 int res1 = 0 ;
46393 PyObject *swig_obj[1] ;
46394
46395 if (!args) SWIG_fail;
46396 swig_obj[0] = args;
46397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46398 if (!SWIG_IsOK(res1)) {
46399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46400 }
46401 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46402 {
46403 PyThreadState* __tstate = wxPyBeginAllowThreads();
46404 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46405 wxPyEndAllowThreads(__tstate);
46406 if (PyErr_Occurred()) SWIG_fail;
46407 }
46408 {
46409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46410 }
46411 return resultobj;
46412 fail:
46413 return NULL;
46414 }
46415
46416
46417 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46418 PyObject *resultobj = 0;
46419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46420 void *argp1 = 0 ;
46421 int res1 = 0 ;
46422 PyObject *swig_obj[1] ;
46423
46424 if (!args) SWIG_fail;
46425 swig_obj[0] = args;
46426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46427 if (!SWIG_IsOK(res1)) {
46428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46429 }
46430 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46431 {
46432 PyThreadState* __tstate = wxPyBeginAllowThreads();
46433 (arg1)->Toggle();
46434 wxPyEndAllowThreads(__tstate);
46435 if (PyErr_Occurred()) SWIG_fail;
46436 }
46437 resultobj = SWIG_Py_Void();
46438 return resultobj;
46439 fail:
46440 return NULL;
46441 }
46442
46443
46444 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46445 PyObject *resultobj = 0;
46446 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46447 wxString *arg2 = 0 ;
46448 void *argp1 = 0 ;
46449 int res1 = 0 ;
46450 bool temp2 = false ;
46451 PyObject * obj0 = 0 ;
46452 PyObject * obj1 = 0 ;
46453 char * kwnames[] = {
46454 (char *) "self",(char *) "str", NULL
46455 };
46456
46457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46459 if (!SWIG_IsOK(res1)) {
46460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46461 }
46462 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46463 {
46464 arg2 = wxString_in_helper(obj1);
46465 if (arg2 == NULL) SWIG_fail;
46466 temp2 = true;
46467 }
46468 {
46469 PyThreadState* __tstate = wxPyBeginAllowThreads();
46470 (arg1)->SetHelp((wxString const &)*arg2);
46471 wxPyEndAllowThreads(__tstate);
46472 if (PyErr_Occurred()) SWIG_fail;
46473 }
46474 resultobj = SWIG_Py_Void();
46475 {
46476 if (temp2)
46477 delete arg2;
46478 }
46479 return resultobj;
46480 fail:
46481 {
46482 if (temp2)
46483 delete arg2;
46484 }
46485 return NULL;
46486 }
46487
46488
46489 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46490 PyObject *resultobj = 0;
46491 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46492 wxString *result = 0 ;
46493 void *argp1 = 0 ;
46494 int res1 = 0 ;
46495 PyObject *swig_obj[1] ;
46496
46497 if (!args) SWIG_fail;
46498 swig_obj[0] = args;
46499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46500 if (!SWIG_IsOK(res1)) {
46501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46502 }
46503 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46504 {
46505 PyThreadState* __tstate = wxPyBeginAllowThreads();
46506 {
46507 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46508 result = (wxString *) &_result_ref;
46509 }
46510 wxPyEndAllowThreads(__tstate);
46511 if (PyErr_Occurred()) SWIG_fail;
46512 }
46513 {
46514 #if wxUSE_UNICODE
46515 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46516 #else
46517 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46518 #endif
46519 }
46520 return resultobj;
46521 fail:
46522 return NULL;
46523 }
46524
46525
46526 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46527 PyObject *resultobj = 0;
46528 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46529 wxAcceleratorEntry *result = 0 ;
46530 void *argp1 = 0 ;
46531 int res1 = 0 ;
46532 PyObject *swig_obj[1] ;
46533
46534 if (!args) SWIG_fail;
46535 swig_obj[0] = args;
46536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46537 if (!SWIG_IsOK(res1)) {
46538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46539 }
46540 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46541 {
46542 PyThreadState* __tstate = wxPyBeginAllowThreads();
46543 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46544 wxPyEndAllowThreads(__tstate);
46545 if (PyErr_Occurred()) SWIG_fail;
46546 }
46547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46548 return resultobj;
46549 fail:
46550 return NULL;
46551 }
46552
46553
46554 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46555 PyObject *resultobj = 0;
46556 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46557 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46558 void *argp1 = 0 ;
46559 int res1 = 0 ;
46560 void *argp2 = 0 ;
46561 int res2 = 0 ;
46562 PyObject * obj0 = 0 ;
46563 PyObject * obj1 = 0 ;
46564 char * kwnames[] = {
46565 (char *) "self",(char *) "accel", NULL
46566 };
46567
46568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46570 if (!SWIG_IsOK(res1)) {
46571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46572 }
46573 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46575 if (!SWIG_IsOK(res2)) {
46576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46577 }
46578 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46579 {
46580 PyThreadState* __tstate = wxPyBeginAllowThreads();
46581 (arg1)->SetAccel(arg2);
46582 wxPyEndAllowThreads(__tstate);
46583 if (PyErr_Occurred()) SWIG_fail;
46584 }
46585 resultobj = SWIG_Py_Void();
46586 return resultobj;
46587 fail:
46588 return NULL;
46589 }
46590
46591
46592 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46593 PyObject *resultobj = 0;
46594 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46595 wxBitmap *arg2 = 0 ;
46596 void *argp1 = 0 ;
46597 int res1 = 0 ;
46598 void *argp2 = 0 ;
46599 int res2 = 0 ;
46600 PyObject * obj0 = 0 ;
46601 PyObject * obj1 = 0 ;
46602 char * kwnames[] = {
46603 (char *) "self",(char *) "bitmap", NULL
46604 };
46605
46606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46608 if (!SWIG_IsOK(res1)) {
46609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46610 }
46611 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46612 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46613 if (!SWIG_IsOK(res2)) {
46614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46615 }
46616 if (!argp2) {
46617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46618 }
46619 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46620 {
46621 PyThreadState* __tstate = wxPyBeginAllowThreads();
46622 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46623 wxPyEndAllowThreads(__tstate);
46624 if (PyErr_Occurred()) SWIG_fail;
46625 }
46626 resultobj = SWIG_Py_Void();
46627 return resultobj;
46628 fail:
46629 return NULL;
46630 }
46631
46632
46633 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46634 PyObject *resultobj = 0;
46635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46636 wxBitmap *result = 0 ;
46637 void *argp1 = 0 ;
46638 int res1 = 0 ;
46639 PyObject *swig_obj[1] ;
46640
46641 if (!args) SWIG_fail;
46642 swig_obj[0] = args;
46643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46644 if (!SWIG_IsOK(res1)) {
46645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46646 }
46647 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46648 {
46649 PyThreadState* __tstate = wxPyBeginAllowThreads();
46650 {
46651 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46652 result = (wxBitmap *) &_result_ref;
46653 }
46654 wxPyEndAllowThreads(__tstate);
46655 if (PyErr_Occurred()) SWIG_fail;
46656 }
46657 {
46658 wxBitmap* resultptr = new wxBitmap(*result);
46659 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46660 }
46661 return resultobj;
46662 fail:
46663 return NULL;
46664 }
46665
46666
46667 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46668 PyObject *resultobj = 0;
46669 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46670 wxFont *arg2 = 0 ;
46671 void *argp1 = 0 ;
46672 int res1 = 0 ;
46673 void *argp2 = 0 ;
46674 int res2 = 0 ;
46675 PyObject * obj0 = 0 ;
46676 PyObject * obj1 = 0 ;
46677 char * kwnames[] = {
46678 (char *) "self",(char *) "font", NULL
46679 };
46680
46681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46683 if (!SWIG_IsOK(res1)) {
46684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46685 }
46686 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46687 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46688 if (!SWIG_IsOK(res2)) {
46689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46690 }
46691 if (!argp2) {
46692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46693 }
46694 arg2 = reinterpret_cast< wxFont * >(argp2);
46695 {
46696 PyThreadState* __tstate = wxPyBeginAllowThreads();
46697 (arg1)->SetFont((wxFont const &)*arg2);
46698 wxPyEndAllowThreads(__tstate);
46699 if (PyErr_Occurred()) SWIG_fail;
46700 }
46701 resultobj = SWIG_Py_Void();
46702 return resultobj;
46703 fail:
46704 return NULL;
46705 }
46706
46707
46708 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46709 PyObject *resultobj = 0;
46710 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46711 wxFont result;
46712 void *argp1 = 0 ;
46713 int res1 = 0 ;
46714 PyObject *swig_obj[1] ;
46715
46716 if (!args) SWIG_fail;
46717 swig_obj[0] = args;
46718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46719 if (!SWIG_IsOK(res1)) {
46720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46721 }
46722 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46723 {
46724 PyThreadState* __tstate = wxPyBeginAllowThreads();
46725 result = (arg1)->GetFont();
46726 wxPyEndAllowThreads(__tstate);
46727 if (PyErr_Occurred()) SWIG_fail;
46728 }
46729 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46730 return resultobj;
46731 fail:
46732 return NULL;
46733 }
46734
46735
46736 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46737 PyObject *resultobj = 0;
46738 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46739 wxColour *arg2 = 0 ;
46740 void *argp1 = 0 ;
46741 int res1 = 0 ;
46742 wxColour temp2 ;
46743 PyObject * obj0 = 0 ;
46744 PyObject * obj1 = 0 ;
46745 char * kwnames[] = {
46746 (char *) "self",(char *) "colText", NULL
46747 };
46748
46749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46751 if (!SWIG_IsOK(res1)) {
46752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46753 }
46754 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46755 {
46756 arg2 = &temp2;
46757 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46758 }
46759 {
46760 PyThreadState* __tstate = wxPyBeginAllowThreads();
46761 (arg1)->SetTextColour((wxColour const &)*arg2);
46762 wxPyEndAllowThreads(__tstate);
46763 if (PyErr_Occurred()) SWIG_fail;
46764 }
46765 resultobj = SWIG_Py_Void();
46766 return resultobj;
46767 fail:
46768 return NULL;
46769 }
46770
46771
46772 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46773 PyObject *resultobj = 0;
46774 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46775 wxColour result;
46776 void *argp1 = 0 ;
46777 int res1 = 0 ;
46778 PyObject *swig_obj[1] ;
46779
46780 if (!args) SWIG_fail;
46781 swig_obj[0] = args;
46782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46783 if (!SWIG_IsOK(res1)) {
46784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46785 }
46786 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46787 {
46788 PyThreadState* __tstate = wxPyBeginAllowThreads();
46789 result = (arg1)->GetTextColour();
46790 wxPyEndAllowThreads(__tstate);
46791 if (PyErr_Occurred()) SWIG_fail;
46792 }
46793 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46794 return resultobj;
46795 fail:
46796 return NULL;
46797 }
46798
46799
46800 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46801 PyObject *resultobj = 0;
46802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46803 wxColour *arg2 = 0 ;
46804 void *argp1 = 0 ;
46805 int res1 = 0 ;
46806 wxColour temp2 ;
46807 PyObject * obj0 = 0 ;
46808 PyObject * obj1 = 0 ;
46809 char * kwnames[] = {
46810 (char *) "self",(char *) "colBack", NULL
46811 };
46812
46813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46815 if (!SWIG_IsOK(res1)) {
46816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46817 }
46818 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46819 {
46820 arg2 = &temp2;
46821 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46822 }
46823 {
46824 PyThreadState* __tstate = wxPyBeginAllowThreads();
46825 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
46826 wxPyEndAllowThreads(__tstate);
46827 if (PyErr_Occurred()) SWIG_fail;
46828 }
46829 resultobj = SWIG_Py_Void();
46830 return resultobj;
46831 fail:
46832 return NULL;
46833 }
46834
46835
46836 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46837 PyObject *resultobj = 0;
46838 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46839 wxColour result;
46840 void *argp1 = 0 ;
46841 int res1 = 0 ;
46842 PyObject *swig_obj[1] ;
46843
46844 if (!args) SWIG_fail;
46845 swig_obj[0] = args;
46846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46847 if (!SWIG_IsOK(res1)) {
46848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46849 }
46850 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46851 {
46852 PyThreadState* __tstate = wxPyBeginAllowThreads();
46853 result = (arg1)->GetBackgroundColour();
46854 wxPyEndAllowThreads(__tstate);
46855 if (PyErr_Occurred()) SWIG_fail;
46856 }
46857 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46858 return resultobj;
46859 fail:
46860 return NULL;
46861 }
46862
46863
46864 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46865 PyObject *resultobj = 0;
46866 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46867 wxBitmap *arg2 = 0 ;
46868 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46869 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46870 void *argp1 = 0 ;
46871 int res1 = 0 ;
46872 void *argp2 = 0 ;
46873 int res2 = 0 ;
46874 void *argp3 = 0 ;
46875 int res3 = 0 ;
46876 PyObject * obj0 = 0 ;
46877 PyObject * obj1 = 0 ;
46878 PyObject * obj2 = 0 ;
46879 char * kwnames[] = {
46880 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46881 };
46882
46883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46885 if (!SWIG_IsOK(res1)) {
46886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46887 }
46888 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46889 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46890 if (!SWIG_IsOK(res2)) {
46891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46892 }
46893 if (!argp2) {
46894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46895 }
46896 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46897 if (obj2) {
46898 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46899 if (!SWIG_IsOK(res3)) {
46900 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46901 }
46902 if (!argp3) {
46903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46904 }
46905 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46906 }
46907 {
46908 PyThreadState* __tstate = wxPyBeginAllowThreads();
46909 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46910 wxPyEndAllowThreads(__tstate);
46911 if (PyErr_Occurred()) SWIG_fail;
46912 }
46913 resultobj = SWIG_Py_Void();
46914 return resultobj;
46915 fail:
46916 return NULL;
46917 }
46918
46919
46920 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46921 PyObject *resultobj = 0;
46922 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46923 wxBitmap *arg2 = 0 ;
46924 void *argp1 = 0 ;
46925 int res1 = 0 ;
46926 void *argp2 = 0 ;
46927 int res2 = 0 ;
46928 PyObject * obj0 = 0 ;
46929 PyObject * obj1 = 0 ;
46930 char * kwnames[] = {
46931 (char *) "self",(char *) "bmpDisabled", NULL
46932 };
46933
46934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46936 if (!SWIG_IsOK(res1)) {
46937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46938 }
46939 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46940 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46941 if (!SWIG_IsOK(res2)) {
46942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46943 }
46944 if (!argp2) {
46945 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46946 }
46947 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46948 {
46949 PyThreadState* __tstate = wxPyBeginAllowThreads();
46950 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
46951 wxPyEndAllowThreads(__tstate);
46952 if (PyErr_Occurred()) SWIG_fail;
46953 }
46954 resultobj = SWIG_Py_Void();
46955 return resultobj;
46956 fail:
46957 return NULL;
46958 }
46959
46960
46961 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46962 PyObject *resultobj = 0;
46963 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46964 wxBitmap *result = 0 ;
46965 void *argp1 = 0 ;
46966 int res1 = 0 ;
46967 PyObject *swig_obj[1] ;
46968
46969 if (!args) SWIG_fail;
46970 swig_obj[0] = args;
46971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46972 if (!SWIG_IsOK(res1)) {
46973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46974 }
46975 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46976 {
46977 PyThreadState* __tstate = wxPyBeginAllowThreads();
46978 {
46979 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
46980 result = (wxBitmap *) &_result_ref;
46981 }
46982 wxPyEndAllowThreads(__tstate);
46983 if (PyErr_Occurred()) SWIG_fail;
46984 }
46985 {
46986 wxBitmap* resultptr = new wxBitmap(*result);
46987 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46988 }
46989 return resultobj;
46990 fail:
46991 return NULL;
46992 }
46993
46994
46995 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46996 PyObject *resultobj = 0;
46997 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46998 int arg2 ;
46999 void *argp1 = 0 ;
47000 int res1 = 0 ;
47001 int val2 ;
47002 int ecode2 = 0 ;
47003 PyObject * obj0 = 0 ;
47004 PyObject * obj1 = 0 ;
47005 char * kwnames[] = {
47006 (char *) "self",(char *) "nWidth", NULL
47007 };
47008
47009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47011 if (!SWIG_IsOK(res1)) {
47012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47013 }
47014 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47015 ecode2 = SWIG_AsVal_int(obj1, &val2);
47016 if (!SWIG_IsOK(ecode2)) {
47017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47018 }
47019 arg2 = static_cast< int >(val2);
47020 {
47021 PyThreadState* __tstate = wxPyBeginAllowThreads();
47022 (arg1)->SetMarginWidth(arg2);
47023 wxPyEndAllowThreads(__tstate);
47024 if (PyErr_Occurred()) SWIG_fail;
47025 }
47026 resultobj = SWIG_Py_Void();
47027 return resultobj;
47028 fail:
47029 return NULL;
47030 }
47031
47032
47033 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47034 PyObject *resultobj = 0;
47035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47036 int result;
47037 void *argp1 = 0 ;
47038 int res1 = 0 ;
47039 PyObject *swig_obj[1] ;
47040
47041 if (!args) SWIG_fail;
47042 swig_obj[0] = args;
47043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47044 if (!SWIG_IsOK(res1)) {
47045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47046 }
47047 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47048 {
47049 PyThreadState* __tstate = wxPyBeginAllowThreads();
47050 result = (int)(arg1)->GetMarginWidth();
47051 wxPyEndAllowThreads(__tstate);
47052 if (PyErr_Occurred()) SWIG_fail;
47053 }
47054 resultobj = SWIG_From_int(static_cast< int >(result));
47055 return resultobj;
47056 fail:
47057 return NULL;
47058 }
47059
47060
47061 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47062 PyObject *resultobj = 0;
47063 int result;
47064
47065 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47066 {
47067 PyThreadState* __tstate = wxPyBeginAllowThreads();
47068 result = (int)wxMenuItem::GetDefaultMarginWidth();
47069 wxPyEndAllowThreads(__tstate);
47070 if (PyErr_Occurred()) SWIG_fail;
47071 }
47072 resultobj = SWIG_From_int(static_cast< int >(result));
47073 return resultobj;
47074 fail:
47075 return NULL;
47076 }
47077
47078
47079 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47080 PyObject *resultobj = 0;
47081 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47082 bool result;
47083 void *argp1 = 0 ;
47084 int res1 = 0 ;
47085 PyObject *swig_obj[1] ;
47086
47087 if (!args) SWIG_fail;
47088 swig_obj[0] = args;
47089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47090 if (!SWIG_IsOK(res1)) {
47091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47092 }
47093 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47094 {
47095 PyThreadState* __tstate = wxPyBeginAllowThreads();
47096 result = (bool)(arg1)->IsOwnerDrawn();
47097 wxPyEndAllowThreads(__tstate);
47098 if (PyErr_Occurred()) SWIG_fail;
47099 }
47100 {
47101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47102 }
47103 return resultobj;
47104 fail:
47105 return NULL;
47106 }
47107
47108
47109 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47110 PyObject *resultobj = 0;
47111 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47112 bool arg2 = (bool) true ;
47113 void *argp1 = 0 ;
47114 int res1 = 0 ;
47115 bool val2 ;
47116 int ecode2 = 0 ;
47117 PyObject * obj0 = 0 ;
47118 PyObject * obj1 = 0 ;
47119 char * kwnames[] = {
47120 (char *) "self",(char *) "ownerDrawn", NULL
47121 };
47122
47123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47125 if (!SWIG_IsOK(res1)) {
47126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47127 }
47128 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47129 if (obj1) {
47130 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47131 if (!SWIG_IsOK(ecode2)) {
47132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47133 }
47134 arg2 = static_cast< bool >(val2);
47135 }
47136 {
47137 PyThreadState* __tstate = wxPyBeginAllowThreads();
47138 (arg1)->SetOwnerDrawn(arg2);
47139 wxPyEndAllowThreads(__tstate);
47140 if (PyErr_Occurred()) SWIG_fail;
47141 }
47142 resultobj = SWIG_Py_Void();
47143 return resultobj;
47144 fail:
47145 return NULL;
47146 }
47147
47148
47149 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47150 PyObject *resultobj = 0;
47151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47152 void *argp1 = 0 ;
47153 int res1 = 0 ;
47154 PyObject *swig_obj[1] ;
47155
47156 if (!args) SWIG_fail;
47157 swig_obj[0] = args;
47158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47159 if (!SWIG_IsOK(res1)) {
47160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47161 }
47162 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47163 {
47164 PyThreadState* __tstate = wxPyBeginAllowThreads();
47165 (arg1)->ResetOwnerDrawn();
47166 wxPyEndAllowThreads(__tstate);
47167 if (PyErr_Occurred()) SWIG_fail;
47168 }
47169 resultobj = SWIG_Py_Void();
47170 return resultobj;
47171 fail:
47172 return NULL;
47173 }
47174
47175
47176 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47177 PyObject *obj;
47178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47179 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47180 return SWIG_Py_Void();
47181 }
47182
47183 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47184 return SWIG_Python_InitShadowInstance(args);
47185 }
47186
47187 SWIGINTERN int ControlNameStr_set(PyObject *) {
47188 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47189 return 1;
47190 }
47191
47192
47193 SWIGINTERN PyObject *ControlNameStr_get(void) {
47194 PyObject *pyobj = 0;
47195
47196 {
47197 #if wxUSE_UNICODE
47198 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47199 #else
47200 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47201 #endif
47202 }
47203 return pyobj;
47204 }
47205
47206
47207 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47208 PyObject *resultobj = 0;
47209 wxWindow *arg1 = (wxWindow *) 0 ;
47210 int arg2 = (int) -1 ;
47211 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47212 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47213 wxSize const &arg4_defvalue = wxDefaultSize ;
47214 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47215 long arg5 = (long) 0 ;
47216 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47217 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47218 wxString const &arg7_defvalue = wxPyControlNameStr ;
47219 wxString *arg7 = (wxString *) &arg7_defvalue ;
47220 wxControl *result = 0 ;
47221 void *argp1 = 0 ;
47222 int res1 = 0 ;
47223 int val2 ;
47224 int ecode2 = 0 ;
47225 wxPoint temp3 ;
47226 wxSize temp4 ;
47227 long val5 ;
47228 int ecode5 = 0 ;
47229 void *argp6 = 0 ;
47230 int res6 = 0 ;
47231 bool temp7 = false ;
47232 PyObject * obj0 = 0 ;
47233 PyObject * obj1 = 0 ;
47234 PyObject * obj2 = 0 ;
47235 PyObject * obj3 = 0 ;
47236 PyObject * obj4 = 0 ;
47237 PyObject * obj5 = 0 ;
47238 PyObject * obj6 = 0 ;
47239 char * kwnames[] = {
47240 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47241 };
47242
47243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47245 if (!SWIG_IsOK(res1)) {
47246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47247 }
47248 arg1 = reinterpret_cast< wxWindow * >(argp1);
47249 if (obj1) {
47250 ecode2 = SWIG_AsVal_int(obj1, &val2);
47251 if (!SWIG_IsOK(ecode2)) {
47252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47253 }
47254 arg2 = static_cast< int >(val2);
47255 }
47256 if (obj2) {
47257 {
47258 arg3 = &temp3;
47259 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47260 }
47261 }
47262 if (obj3) {
47263 {
47264 arg4 = &temp4;
47265 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47266 }
47267 }
47268 if (obj4) {
47269 ecode5 = SWIG_AsVal_long(obj4, &val5);
47270 if (!SWIG_IsOK(ecode5)) {
47271 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47272 }
47273 arg5 = static_cast< long >(val5);
47274 }
47275 if (obj5) {
47276 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47277 if (!SWIG_IsOK(res6)) {
47278 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47279 }
47280 if (!argp6) {
47281 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47282 }
47283 arg6 = reinterpret_cast< wxValidator * >(argp6);
47284 }
47285 if (obj6) {
47286 {
47287 arg7 = wxString_in_helper(obj6);
47288 if (arg7 == NULL) SWIG_fail;
47289 temp7 = true;
47290 }
47291 }
47292 {
47293 if (!wxPyCheckForApp()) SWIG_fail;
47294 PyThreadState* __tstate = wxPyBeginAllowThreads();
47295 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47296 wxPyEndAllowThreads(__tstate);
47297 if (PyErr_Occurred()) SWIG_fail;
47298 }
47299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47300 {
47301 if (temp7)
47302 delete arg7;
47303 }
47304 return resultobj;
47305 fail:
47306 {
47307 if (temp7)
47308 delete arg7;
47309 }
47310 return NULL;
47311 }
47312
47313
47314 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47315 PyObject *resultobj = 0;
47316 wxControl *result = 0 ;
47317
47318 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47319 {
47320 if (!wxPyCheckForApp()) SWIG_fail;
47321 PyThreadState* __tstate = wxPyBeginAllowThreads();
47322 result = (wxControl *)new wxControl();
47323 wxPyEndAllowThreads(__tstate);
47324 if (PyErr_Occurred()) SWIG_fail;
47325 }
47326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47327 return resultobj;
47328 fail:
47329 return NULL;
47330 }
47331
47332
47333 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47334 PyObject *resultobj = 0;
47335 wxControl *arg1 = (wxControl *) 0 ;
47336 wxWindow *arg2 = (wxWindow *) 0 ;
47337 int arg3 = (int) -1 ;
47338 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47339 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47340 wxSize const &arg5_defvalue = wxDefaultSize ;
47341 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47342 long arg6 = (long) 0 ;
47343 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47344 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47345 wxString const &arg8_defvalue = wxPyControlNameStr ;
47346 wxString *arg8 = (wxString *) &arg8_defvalue ;
47347 bool result;
47348 void *argp1 = 0 ;
47349 int res1 = 0 ;
47350 void *argp2 = 0 ;
47351 int res2 = 0 ;
47352 int val3 ;
47353 int ecode3 = 0 ;
47354 wxPoint temp4 ;
47355 wxSize temp5 ;
47356 long val6 ;
47357 int ecode6 = 0 ;
47358 void *argp7 = 0 ;
47359 int res7 = 0 ;
47360 bool temp8 = false ;
47361 PyObject * obj0 = 0 ;
47362 PyObject * obj1 = 0 ;
47363 PyObject * obj2 = 0 ;
47364 PyObject * obj3 = 0 ;
47365 PyObject * obj4 = 0 ;
47366 PyObject * obj5 = 0 ;
47367 PyObject * obj6 = 0 ;
47368 PyObject * obj7 = 0 ;
47369 char * kwnames[] = {
47370 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47371 };
47372
47373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47375 if (!SWIG_IsOK(res1)) {
47376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47377 }
47378 arg1 = reinterpret_cast< wxControl * >(argp1);
47379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47380 if (!SWIG_IsOK(res2)) {
47381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47382 }
47383 arg2 = reinterpret_cast< wxWindow * >(argp2);
47384 if (obj2) {
47385 ecode3 = SWIG_AsVal_int(obj2, &val3);
47386 if (!SWIG_IsOK(ecode3)) {
47387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47388 }
47389 arg3 = static_cast< int >(val3);
47390 }
47391 if (obj3) {
47392 {
47393 arg4 = &temp4;
47394 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47395 }
47396 }
47397 if (obj4) {
47398 {
47399 arg5 = &temp5;
47400 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47401 }
47402 }
47403 if (obj5) {
47404 ecode6 = SWIG_AsVal_long(obj5, &val6);
47405 if (!SWIG_IsOK(ecode6)) {
47406 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47407 }
47408 arg6 = static_cast< long >(val6);
47409 }
47410 if (obj6) {
47411 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47412 if (!SWIG_IsOK(res7)) {
47413 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47414 }
47415 if (!argp7) {
47416 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47417 }
47418 arg7 = reinterpret_cast< wxValidator * >(argp7);
47419 }
47420 if (obj7) {
47421 {
47422 arg8 = wxString_in_helper(obj7);
47423 if (arg8 == NULL) SWIG_fail;
47424 temp8 = true;
47425 }
47426 }
47427 {
47428 PyThreadState* __tstate = wxPyBeginAllowThreads();
47429 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47430 wxPyEndAllowThreads(__tstate);
47431 if (PyErr_Occurred()) SWIG_fail;
47432 }
47433 {
47434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47435 }
47436 {
47437 if (temp8)
47438 delete arg8;
47439 }
47440 return resultobj;
47441 fail:
47442 {
47443 if (temp8)
47444 delete arg8;
47445 }
47446 return NULL;
47447 }
47448
47449
47450 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47451 PyObject *resultobj = 0;
47452 wxControl *arg1 = (wxControl *) 0 ;
47453 int result;
47454 void *argp1 = 0 ;
47455 int res1 = 0 ;
47456 PyObject *swig_obj[1] ;
47457
47458 if (!args) SWIG_fail;
47459 swig_obj[0] = args;
47460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47461 if (!SWIG_IsOK(res1)) {
47462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47463 }
47464 arg1 = reinterpret_cast< wxControl * >(argp1);
47465 {
47466 PyThreadState* __tstate = wxPyBeginAllowThreads();
47467 result = (int)((wxControl const *)arg1)->GetAlignment();
47468 wxPyEndAllowThreads(__tstate);
47469 if (PyErr_Occurred()) SWIG_fail;
47470 }
47471 resultobj = SWIG_From_int(static_cast< int >(result));
47472 return resultobj;
47473 fail:
47474 return NULL;
47475 }
47476
47477
47478 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47479 PyObject *resultobj = 0;
47480 wxControl *arg1 = (wxControl *) 0 ;
47481 wxString result;
47482 void *argp1 = 0 ;
47483 int res1 = 0 ;
47484 PyObject *swig_obj[1] ;
47485
47486 if (!args) SWIG_fail;
47487 swig_obj[0] = args;
47488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47489 if (!SWIG_IsOK(res1)) {
47490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47491 }
47492 arg1 = reinterpret_cast< wxControl * >(argp1);
47493 {
47494 PyThreadState* __tstate = wxPyBeginAllowThreads();
47495 result = ((wxControl const *)arg1)->GetLabelText();
47496 wxPyEndAllowThreads(__tstate);
47497 if (PyErr_Occurred()) SWIG_fail;
47498 }
47499 {
47500 #if wxUSE_UNICODE
47501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47502 #else
47503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47504 #endif
47505 }
47506 return resultobj;
47507 fail:
47508 return NULL;
47509 }
47510
47511
47512 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47513 PyObject *resultobj = 0;
47514 wxControl *arg1 = (wxControl *) 0 ;
47515 wxCommandEvent *arg2 = 0 ;
47516 void *argp1 = 0 ;
47517 int res1 = 0 ;
47518 void *argp2 = 0 ;
47519 int res2 = 0 ;
47520 PyObject * obj0 = 0 ;
47521 PyObject * obj1 = 0 ;
47522 char * kwnames[] = {
47523 (char *) "self",(char *) "event", NULL
47524 };
47525
47526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47528 if (!SWIG_IsOK(res1)) {
47529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47530 }
47531 arg1 = reinterpret_cast< wxControl * >(argp1);
47532 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47533 if (!SWIG_IsOK(res2)) {
47534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47535 }
47536 if (!argp2) {
47537 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47538 }
47539 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47540 {
47541 PyThreadState* __tstate = wxPyBeginAllowThreads();
47542 (arg1)->Command(*arg2);
47543 wxPyEndAllowThreads(__tstate);
47544 if (PyErr_Occurred()) SWIG_fail;
47545 }
47546 resultobj = SWIG_Py_Void();
47547 return resultobj;
47548 fail:
47549 return NULL;
47550 }
47551
47552
47553 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47554 PyObject *resultobj = 0;
47555 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47556 SwigValueWrapper<wxVisualAttributes > result;
47557 int val1 ;
47558 int ecode1 = 0 ;
47559 PyObject * obj0 = 0 ;
47560 char * kwnames[] = {
47561 (char *) "variant", NULL
47562 };
47563
47564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47565 if (obj0) {
47566 ecode1 = SWIG_AsVal_int(obj0, &val1);
47567 if (!SWIG_IsOK(ecode1)) {
47568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47569 }
47570 arg1 = static_cast< wxWindowVariant >(val1);
47571 }
47572 {
47573 if (!wxPyCheckForApp()) SWIG_fail;
47574 PyThreadState* __tstate = wxPyBeginAllowThreads();
47575 result = wxControl::GetClassDefaultAttributes(arg1);
47576 wxPyEndAllowThreads(__tstate);
47577 if (PyErr_Occurred()) SWIG_fail;
47578 }
47579 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47580 return resultobj;
47581 fail:
47582 return NULL;
47583 }
47584
47585
47586 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47587 PyObject *obj;
47588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47589 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47590 return SWIG_Py_Void();
47591 }
47592
47593 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47594 return SWIG_Python_InitShadowInstance(args);
47595 }
47596
47597 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47598 PyObject *resultobj = 0;
47599 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47600 wxString *arg2 = 0 ;
47601 PyObject *arg3 = (PyObject *) NULL ;
47602 int result;
47603 void *argp1 = 0 ;
47604 int res1 = 0 ;
47605 bool temp2 = false ;
47606 PyObject * obj0 = 0 ;
47607 PyObject * obj1 = 0 ;
47608 PyObject * obj2 = 0 ;
47609 char * kwnames[] = {
47610 (char *) "self",(char *) "item",(char *) "clientData", NULL
47611 };
47612
47613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47615 if (!SWIG_IsOK(res1)) {
47616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47617 }
47618 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47619 {
47620 arg2 = wxString_in_helper(obj1);
47621 if (arg2 == NULL) SWIG_fail;
47622 temp2 = true;
47623 }
47624 if (obj2) {
47625 arg3 = obj2;
47626 }
47627 {
47628 PyThreadState* __tstate = wxPyBeginAllowThreads();
47629 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47630 wxPyEndAllowThreads(__tstate);
47631 if (PyErr_Occurred()) SWIG_fail;
47632 }
47633 resultobj = SWIG_From_int(static_cast< int >(result));
47634 {
47635 if (temp2)
47636 delete arg2;
47637 }
47638 return resultobj;
47639 fail:
47640 {
47641 if (temp2)
47642 delete arg2;
47643 }
47644 return NULL;
47645 }
47646
47647
47648 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47649 PyObject *resultobj = 0;
47650 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47651 wxArrayString *arg2 = 0 ;
47652 void *argp1 = 0 ;
47653 int res1 = 0 ;
47654 bool temp2 = false ;
47655 PyObject * obj0 = 0 ;
47656 PyObject * obj1 = 0 ;
47657 char * kwnames[] = {
47658 (char *) "self",(char *) "strings", NULL
47659 };
47660
47661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47663 if (!SWIG_IsOK(res1)) {
47664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47665 }
47666 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47667 {
47668 if (! PySequence_Check(obj1)) {
47669 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47670 SWIG_fail;
47671 }
47672 arg2 = new wxArrayString;
47673 temp2 = true;
47674 int i, len=PySequence_Length(obj1);
47675 for (i=0; i<len; i++) {
47676 PyObject* item = PySequence_GetItem(obj1, i);
47677 wxString* s = wxString_in_helper(item);
47678 if (PyErr_Occurred()) SWIG_fail;
47679 arg2->Add(*s);
47680 delete s;
47681 Py_DECREF(item);
47682 }
47683 }
47684 {
47685 PyThreadState* __tstate = wxPyBeginAllowThreads();
47686 (arg1)->Append((wxArrayString const &)*arg2);
47687 wxPyEndAllowThreads(__tstate);
47688 if (PyErr_Occurred()) SWIG_fail;
47689 }
47690 resultobj = SWIG_Py_Void();
47691 {
47692 if (temp2) delete arg2;
47693 }
47694 return resultobj;
47695 fail:
47696 {
47697 if (temp2) delete arg2;
47698 }
47699 return NULL;
47700 }
47701
47702
47703 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47704 PyObject *resultobj = 0;
47705 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47706 wxString *arg2 = 0 ;
47707 unsigned int arg3 ;
47708 PyObject *arg4 = (PyObject *) NULL ;
47709 int result;
47710 void *argp1 = 0 ;
47711 int res1 = 0 ;
47712 bool temp2 = false ;
47713 unsigned int val3 ;
47714 int ecode3 = 0 ;
47715 PyObject * obj0 = 0 ;
47716 PyObject * obj1 = 0 ;
47717 PyObject * obj2 = 0 ;
47718 PyObject * obj3 = 0 ;
47719 char * kwnames[] = {
47720 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47721 };
47722
47723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47725 if (!SWIG_IsOK(res1)) {
47726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47727 }
47728 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47729 {
47730 arg2 = wxString_in_helper(obj1);
47731 if (arg2 == NULL) SWIG_fail;
47732 temp2 = true;
47733 }
47734 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47735 if (!SWIG_IsOK(ecode3)) {
47736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47737 }
47738 arg3 = static_cast< unsigned int >(val3);
47739 if (obj3) {
47740 arg4 = obj3;
47741 }
47742 {
47743 PyThreadState* __tstate = wxPyBeginAllowThreads();
47744 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47745 wxPyEndAllowThreads(__tstate);
47746 if (PyErr_Occurred()) SWIG_fail;
47747 }
47748 resultobj = SWIG_From_int(static_cast< int >(result));
47749 {
47750 if (temp2)
47751 delete arg2;
47752 }
47753 return resultobj;
47754 fail:
47755 {
47756 if (temp2)
47757 delete arg2;
47758 }
47759 return NULL;
47760 }
47761
47762
47763 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47764 PyObject *resultobj = 0;
47765 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47766 void *argp1 = 0 ;
47767 int res1 = 0 ;
47768 PyObject *swig_obj[1] ;
47769
47770 if (!args) SWIG_fail;
47771 swig_obj[0] = args;
47772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47773 if (!SWIG_IsOK(res1)) {
47774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47775 }
47776 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47777 {
47778 PyThreadState* __tstate = wxPyBeginAllowThreads();
47779 (arg1)->Clear();
47780 wxPyEndAllowThreads(__tstate);
47781 if (PyErr_Occurred()) SWIG_fail;
47782 }
47783 resultobj = SWIG_Py_Void();
47784 return resultobj;
47785 fail:
47786 return NULL;
47787 }
47788
47789
47790 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47791 PyObject *resultobj = 0;
47792 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47793 unsigned int arg2 ;
47794 void *argp1 = 0 ;
47795 int res1 = 0 ;
47796 unsigned int val2 ;
47797 int ecode2 = 0 ;
47798 PyObject * obj0 = 0 ;
47799 PyObject * obj1 = 0 ;
47800 char * kwnames[] = {
47801 (char *) "self",(char *) "n", NULL
47802 };
47803
47804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) 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_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47808 }
47809 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47810 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47811 if (!SWIG_IsOK(ecode2)) {
47812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47813 }
47814 arg2 = static_cast< unsigned int >(val2);
47815 {
47816 PyThreadState* __tstate = wxPyBeginAllowThreads();
47817 (arg1)->Delete(arg2);
47818 wxPyEndAllowThreads(__tstate);
47819 if (PyErr_Occurred()) SWIG_fail;
47820 }
47821 resultobj = SWIG_Py_Void();
47822 return resultobj;
47823 fail:
47824 return NULL;
47825 }
47826
47827
47828 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47829 PyObject *resultobj = 0;
47830 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47831 unsigned int arg2 ;
47832 PyObject *result = 0 ;
47833 void *argp1 = 0 ;
47834 int res1 = 0 ;
47835 unsigned int val2 ;
47836 int ecode2 = 0 ;
47837 PyObject * obj0 = 0 ;
47838 PyObject * obj1 = 0 ;
47839 char * kwnames[] = {
47840 (char *) "self",(char *) "n", NULL
47841 };
47842
47843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47845 if (!SWIG_IsOK(res1)) {
47846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47847 }
47848 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47849 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47850 if (!SWIG_IsOK(ecode2)) {
47851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47852 }
47853 arg2 = static_cast< unsigned int >(val2);
47854 {
47855 PyThreadState* __tstate = wxPyBeginAllowThreads();
47856 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47857 wxPyEndAllowThreads(__tstate);
47858 if (PyErr_Occurred()) SWIG_fail;
47859 }
47860 resultobj = result;
47861 return resultobj;
47862 fail:
47863 return NULL;
47864 }
47865
47866
47867 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47868 PyObject *resultobj = 0;
47869 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47870 unsigned int arg2 ;
47871 PyObject *arg3 = (PyObject *) 0 ;
47872 void *argp1 = 0 ;
47873 int res1 = 0 ;
47874 unsigned int val2 ;
47875 int ecode2 = 0 ;
47876 PyObject * obj0 = 0 ;
47877 PyObject * obj1 = 0 ;
47878 PyObject * obj2 = 0 ;
47879 char * kwnames[] = {
47880 (char *) "self",(char *) "n",(char *) "clientData", NULL
47881 };
47882
47883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47885 if (!SWIG_IsOK(res1)) {
47886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47887 }
47888 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47889 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47890 if (!SWIG_IsOK(ecode2)) {
47891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47892 }
47893 arg2 = static_cast< unsigned int >(val2);
47894 arg3 = obj2;
47895 {
47896 PyThreadState* __tstate = wxPyBeginAllowThreads();
47897 wxItemContainer_SetClientData(arg1,arg2,arg3);
47898 wxPyEndAllowThreads(__tstate);
47899 if (PyErr_Occurred()) SWIG_fail;
47900 }
47901 resultobj = SWIG_Py_Void();
47902 return resultobj;
47903 fail:
47904 return NULL;
47905 }
47906
47907
47908 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47909 PyObject *resultobj = 0;
47910 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47911 unsigned int result;
47912 void *argp1 = 0 ;
47913 int res1 = 0 ;
47914 PyObject *swig_obj[1] ;
47915
47916 if (!args) SWIG_fail;
47917 swig_obj[0] = args;
47918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47919 if (!SWIG_IsOK(res1)) {
47920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47921 }
47922 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47923 {
47924 PyThreadState* __tstate = wxPyBeginAllowThreads();
47925 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47926 wxPyEndAllowThreads(__tstate);
47927 if (PyErr_Occurred()) SWIG_fail;
47928 }
47929 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47930 return resultobj;
47931 fail:
47932 return NULL;
47933 }
47934
47935
47936 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47937 PyObject *resultobj = 0;
47938 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47939 bool result;
47940 void *argp1 = 0 ;
47941 int res1 = 0 ;
47942 PyObject *swig_obj[1] ;
47943
47944 if (!args) SWIG_fail;
47945 swig_obj[0] = args;
47946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47947 if (!SWIG_IsOK(res1)) {
47948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47949 }
47950 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47951 {
47952 PyThreadState* __tstate = wxPyBeginAllowThreads();
47953 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47954 wxPyEndAllowThreads(__tstate);
47955 if (PyErr_Occurred()) SWIG_fail;
47956 }
47957 {
47958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47959 }
47960 return resultobj;
47961 fail:
47962 return NULL;
47963 }
47964
47965
47966 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47967 PyObject *resultobj = 0;
47968 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47969 unsigned int arg2 ;
47970 wxString result;
47971 void *argp1 = 0 ;
47972 int res1 = 0 ;
47973 unsigned int val2 ;
47974 int ecode2 = 0 ;
47975 PyObject * obj0 = 0 ;
47976 PyObject * obj1 = 0 ;
47977 char * kwnames[] = {
47978 (char *) "self",(char *) "n", NULL
47979 };
47980
47981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
47982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47983 if (!SWIG_IsOK(res1)) {
47984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47985 }
47986 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47987 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47988 if (!SWIG_IsOK(ecode2)) {
47989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
47990 }
47991 arg2 = static_cast< unsigned int >(val2);
47992 {
47993 PyThreadState* __tstate = wxPyBeginAllowThreads();
47994 result = ((wxItemContainer const *)arg1)->GetString(arg2);
47995 wxPyEndAllowThreads(__tstate);
47996 if (PyErr_Occurred()) SWIG_fail;
47997 }
47998 {
47999 #if wxUSE_UNICODE
48000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48001 #else
48002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48003 #endif
48004 }
48005 return resultobj;
48006 fail:
48007 return NULL;
48008 }
48009
48010
48011 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48012 PyObject *resultobj = 0;
48013 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48014 wxArrayString result;
48015 void *argp1 = 0 ;
48016 int res1 = 0 ;
48017 PyObject *swig_obj[1] ;
48018
48019 if (!args) SWIG_fail;
48020 swig_obj[0] = args;
48021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48022 if (!SWIG_IsOK(res1)) {
48023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48024 }
48025 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48026 {
48027 PyThreadState* __tstate = wxPyBeginAllowThreads();
48028 result = ((wxItemContainer const *)arg1)->GetStrings();
48029 wxPyEndAllowThreads(__tstate);
48030 if (PyErr_Occurred()) SWIG_fail;
48031 }
48032 {
48033 resultobj = wxArrayString2PyList_helper(result);
48034 }
48035 return resultobj;
48036 fail:
48037 return NULL;
48038 }
48039
48040
48041 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48042 PyObject *resultobj = 0;
48043 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48044 unsigned int arg2 ;
48045 wxString *arg3 = 0 ;
48046 void *argp1 = 0 ;
48047 int res1 = 0 ;
48048 unsigned int val2 ;
48049 int ecode2 = 0 ;
48050 bool temp3 = false ;
48051 PyObject * obj0 = 0 ;
48052 PyObject * obj1 = 0 ;
48053 PyObject * obj2 = 0 ;
48054 char * kwnames[] = {
48055 (char *) "self",(char *) "n",(char *) "s", NULL
48056 };
48057
48058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48060 if (!SWIG_IsOK(res1)) {
48061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48062 }
48063 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48064 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48065 if (!SWIG_IsOK(ecode2)) {
48066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48067 }
48068 arg2 = static_cast< unsigned int >(val2);
48069 {
48070 arg3 = wxString_in_helper(obj2);
48071 if (arg3 == NULL) SWIG_fail;
48072 temp3 = true;
48073 }
48074 {
48075 PyThreadState* __tstate = wxPyBeginAllowThreads();
48076 (arg1)->SetString(arg2,(wxString const &)*arg3);
48077 wxPyEndAllowThreads(__tstate);
48078 if (PyErr_Occurred()) SWIG_fail;
48079 }
48080 resultobj = SWIG_Py_Void();
48081 {
48082 if (temp3)
48083 delete arg3;
48084 }
48085 return resultobj;
48086 fail:
48087 {
48088 if (temp3)
48089 delete arg3;
48090 }
48091 return NULL;
48092 }
48093
48094
48095 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48096 PyObject *resultobj = 0;
48097 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48098 wxString *arg2 = 0 ;
48099 int result;
48100 void *argp1 = 0 ;
48101 int res1 = 0 ;
48102 bool temp2 = false ;
48103 PyObject * obj0 = 0 ;
48104 PyObject * obj1 = 0 ;
48105 char * kwnames[] = {
48106 (char *) "self",(char *) "s", NULL
48107 };
48108
48109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48111 if (!SWIG_IsOK(res1)) {
48112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48113 }
48114 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48115 {
48116 arg2 = wxString_in_helper(obj1);
48117 if (arg2 == NULL) SWIG_fail;
48118 temp2 = true;
48119 }
48120 {
48121 PyThreadState* __tstate = wxPyBeginAllowThreads();
48122 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48123 wxPyEndAllowThreads(__tstate);
48124 if (PyErr_Occurred()) SWIG_fail;
48125 }
48126 resultobj = SWIG_From_int(static_cast< int >(result));
48127 {
48128 if (temp2)
48129 delete arg2;
48130 }
48131 return resultobj;
48132 fail:
48133 {
48134 if (temp2)
48135 delete arg2;
48136 }
48137 return NULL;
48138 }
48139
48140
48141 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48142 PyObject *resultobj = 0;
48143 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48144 int arg2 ;
48145 void *argp1 = 0 ;
48146 int res1 = 0 ;
48147 int val2 ;
48148 int ecode2 = 0 ;
48149 PyObject * obj0 = 0 ;
48150 PyObject * obj1 = 0 ;
48151 char * kwnames[] = {
48152 (char *) "self",(char *) "n", NULL
48153 };
48154
48155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48157 if (!SWIG_IsOK(res1)) {
48158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48159 }
48160 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48161 ecode2 = SWIG_AsVal_int(obj1, &val2);
48162 if (!SWIG_IsOK(ecode2)) {
48163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48164 }
48165 arg2 = static_cast< int >(val2);
48166 {
48167 PyThreadState* __tstate = wxPyBeginAllowThreads();
48168 (arg1)->SetSelection(arg2);
48169 wxPyEndAllowThreads(__tstate);
48170 if (PyErr_Occurred()) SWIG_fail;
48171 }
48172 resultobj = SWIG_Py_Void();
48173 return resultobj;
48174 fail:
48175 return NULL;
48176 }
48177
48178
48179 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48180 PyObject *resultobj = 0;
48181 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48182 int result;
48183 void *argp1 = 0 ;
48184 int res1 = 0 ;
48185 PyObject *swig_obj[1] ;
48186
48187 if (!args) SWIG_fail;
48188 swig_obj[0] = args;
48189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48190 if (!SWIG_IsOK(res1)) {
48191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48192 }
48193 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48194 {
48195 PyThreadState* __tstate = wxPyBeginAllowThreads();
48196 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48197 wxPyEndAllowThreads(__tstate);
48198 if (PyErr_Occurred()) SWIG_fail;
48199 }
48200 resultobj = SWIG_From_int(static_cast< int >(result));
48201 return resultobj;
48202 fail:
48203 return NULL;
48204 }
48205
48206
48207 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48208 PyObject *resultobj = 0;
48209 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48210 wxString *arg2 = 0 ;
48211 bool result;
48212 void *argp1 = 0 ;
48213 int res1 = 0 ;
48214 bool temp2 = false ;
48215 PyObject * obj0 = 0 ;
48216 PyObject * obj1 = 0 ;
48217 char * kwnames[] = {
48218 (char *) "self",(char *) "s", NULL
48219 };
48220
48221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48223 if (!SWIG_IsOK(res1)) {
48224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48225 }
48226 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48227 {
48228 arg2 = wxString_in_helper(obj1);
48229 if (arg2 == NULL) SWIG_fail;
48230 temp2 = true;
48231 }
48232 {
48233 PyThreadState* __tstate = wxPyBeginAllowThreads();
48234 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48235 wxPyEndAllowThreads(__tstate);
48236 if (PyErr_Occurred()) SWIG_fail;
48237 }
48238 {
48239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48240 }
48241 {
48242 if (temp2)
48243 delete arg2;
48244 }
48245 return resultobj;
48246 fail:
48247 {
48248 if (temp2)
48249 delete arg2;
48250 }
48251 return NULL;
48252 }
48253
48254
48255 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48256 PyObject *resultobj = 0;
48257 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48258 wxString result;
48259 void *argp1 = 0 ;
48260 int res1 = 0 ;
48261 PyObject *swig_obj[1] ;
48262
48263 if (!args) SWIG_fail;
48264 swig_obj[0] = args;
48265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48266 if (!SWIG_IsOK(res1)) {
48267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48268 }
48269 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48270 {
48271 PyThreadState* __tstate = wxPyBeginAllowThreads();
48272 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48273 wxPyEndAllowThreads(__tstate);
48274 if (PyErr_Occurred()) SWIG_fail;
48275 }
48276 {
48277 #if wxUSE_UNICODE
48278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48279 #else
48280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48281 #endif
48282 }
48283 return resultobj;
48284 fail:
48285 return NULL;
48286 }
48287
48288
48289 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48290 PyObject *resultobj = 0;
48291 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48292 int arg2 ;
48293 void *argp1 = 0 ;
48294 int res1 = 0 ;
48295 int val2 ;
48296 int ecode2 = 0 ;
48297 PyObject * obj0 = 0 ;
48298 PyObject * obj1 = 0 ;
48299 char * kwnames[] = {
48300 (char *) "self",(char *) "n", NULL
48301 };
48302
48303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48305 if (!SWIG_IsOK(res1)) {
48306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48307 }
48308 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48309 ecode2 = SWIG_AsVal_int(obj1, &val2);
48310 if (!SWIG_IsOK(ecode2)) {
48311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48312 }
48313 arg2 = static_cast< int >(val2);
48314 {
48315 PyThreadState* __tstate = wxPyBeginAllowThreads();
48316 (arg1)->Select(arg2);
48317 wxPyEndAllowThreads(__tstate);
48318 if (PyErr_Occurred()) SWIG_fail;
48319 }
48320 resultobj = SWIG_Py_Void();
48321 return resultobj;
48322 fail:
48323 return NULL;
48324 }
48325
48326
48327 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48328 PyObject *obj;
48329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48330 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48331 return SWIG_Py_Void();
48332 }
48333
48334 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48335 PyObject *obj;
48336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48337 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48338 return SWIG_Py_Void();
48339 }
48340
48341 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48342 PyObject *resultobj = 0;
48343 wxSizerItem *result = 0 ;
48344
48345 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48346 {
48347 PyThreadState* __tstate = wxPyBeginAllowThreads();
48348 result = (wxSizerItem *)new wxSizerItem();
48349 wxPyEndAllowThreads(__tstate);
48350 if (PyErr_Occurred()) SWIG_fail;
48351 }
48352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48353 return resultobj;
48354 fail:
48355 return NULL;
48356 }
48357
48358
48359 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48360 PyObject *resultobj = 0;
48361 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48362 void *argp1 = 0 ;
48363 int res1 = 0 ;
48364 PyObject *swig_obj[1] ;
48365
48366 if (!args) SWIG_fail;
48367 swig_obj[0] = args;
48368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48369 if (!SWIG_IsOK(res1)) {
48370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48371 }
48372 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48373 {
48374 PyThreadState* __tstate = wxPyBeginAllowThreads();
48375 delete arg1;
48376
48377 wxPyEndAllowThreads(__tstate);
48378 if (PyErr_Occurred()) SWIG_fail;
48379 }
48380 resultobj = SWIG_Py_Void();
48381 return resultobj;
48382 fail:
48383 return NULL;
48384 }
48385
48386
48387 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48388 PyObject *resultobj = 0;
48389 wxWindow *arg1 = (wxWindow *) 0 ;
48390 int arg2 ;
48391 int arg3 ;
48392 int arg4 ;
48393 PyObject *arg5 = (PyObject *) NULL ;
48394 wxSizerItem *result = 0 ;
48395 void *argp1 = 0 ;
48396 int res1 = 0 ;
48397 int val2 ;
48398 int ecode2 = 0 ;
48399 int val3 ;
48400 int ecode3 = 0 ;
48401 int val4 ;
48402 int ecode4 = 0 ;
48403 PyObject * obj0 = 0 ;
48404 PyObject * obj1 = 0 ;
48405 PyObject * obj2 = 0 ;
48406 PyObject * obj3 = 0 ;
48407 PyObject * obj4 = 0 ;
48408 char * kwnames[] = {
48409 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48410 };
48411
48412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48414 if (!SWIG_IsOK(res1)) {
48415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48416 }
48417 arg1 = reinterpret_cast< wxWindow * >(argp1);
48418 ecode2 = SWIG_AsVal_int(obj1, &val2);
48419 if (!SWIG_IsOK(ecode2)) {
48420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48421 }
48422 arg2 = static_cast< int >(val2);
48423 ecode3 = SWIG_AsVal_int(obj2, &val3);
48424 if (!SWIG_IsOK(ecode3)) {
48425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48426 }
48427 arg3 = static_cast< int >(val3);
48428 ecode4 = SWIG_AsVal_int(obj3, &val4);
48429 if (!SWIG_IsOK(ecode4)) {
48430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48431 }
48432 arg4 = static_cast< int >(val4);
48433 if (obj4) {
48434 arg5 = obj4;
48435 }
48436 {
48437 PyThreadState* __tstate = wxPyBeginAllowThreads();
48438 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48439 wxPyEndAllowThreads(__tstate);
48440 if (PyErr_Occurred()) SWIG_fail;
48441 }
48442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48443 return resultobj;
48444 fail:
48445 return NULL;
48446 }
48447
48448
48449 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48450 PyObject *resultobj = 0;
48451 int arg1 ;
48452 int arg2 ;
48453 int arg3 ;
48454 int arg4 ;
48455 int arg5 ;
48456 PyObject *arg6 = (PyObject *) NULL ;
48457 wxSizerItem *result = 0 ;
48458 int val1 ;
48459 int ecode1 = 0 ;
48460 int val2 ;
48461 int ecode2 = 0 ;
48462 int val3 ;
48463 int ecode3 = 0 ;
48464 int val4 ;
48465 int ecode4 = 0 ;
48466 int val5 ;
48467 int ecode5 = 0 ;
48468 PyObject * obj0 = 0 ;
48469 PyObject * obj1 = 0 ;
48470 PyObject * obj2 = 0 ;
48471 PyObject * obj3 = 0 ;
48472 PyObject * obj4 = 0 ;
48473 PyObject * obj5 = 0 ;
48474 char * kwnames[] = {
48475 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48476 };
48477
48478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48479 ecode1 = SWIG_AsVal_int(obj0, &val1);
48480 if (!SWIG_IsOK(ecode1)) {
48481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48482 }
48483 arg1 = static_cast< int >(val1);
48484 ecode2 = SWIG_AsVal_int(obj1, &val2);
48485 if (!SWIG_IsOK(ecode2)) {
48486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48487 }
48488 arg2 = static_cast< int >(val2);
48489 ecode3 = SWIG_AsVal_int(obj2, &val3);
48490 if (!SWIG_IsOK(ecode3)) {
48491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48492 }
48493 arg3 = static_cast< int >(val3);
48494 ecode4 = SWIG_AsVal_int(obj3, &val4);
48495 if (!SWIG_IsOK(ecode4)) {
48496 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48497 }
48498 arg4 = static_cast< int >(val4);
48499 ecode5 = SWIG_AsVal_int(obj4, &val5);
48500 if (!SWIG_IsOK(ecode5)) {
48501 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48502 }
48503 arg5 = static_cast< int >(val5);
48504 if (obj5) {
48505 arg6 = obj5;
48506 }
48507 {
48508 PyThreadState* __tstate = wxPyBeginAllowThreads();
48509 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48510 wxPyEndAllowThreads(__tstate);
48511 if (PyErr_Occurred()) SWIG_fail;
48512 }
48513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48514 return resultobj;
48515 fail:
48516 return NULL;
48517 }
48518
48519
48520 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48521 PyObject *resultobj = 0;
48522 wxSizer *arg1 = (wxSizer *) 0 ;
48523 int arg2 ;
48524 int arg3 ;
48525 int arg4 ;
48526 PyObject *arg5 = (PyObject *) NULL ;
48527 wxSizerItem *result = 0 ;
48528 int res1 = 0 ;
48529 int val2 ;
48530 int ecode2 = 0 ;
48531 int val3 ;
48532 int ecode3 = 0 ;
48533 int val4 ;
48534 int ecode4 = 0 ;
48535 PyObject * obj0 = 0 ;
48536 PyObject * obj1 = 0 ;
48537 PyObject * obj2 = 0 ;
48538 PyObject * obj3 = 0 ;
48539 PyObject * obj4 = 0 ;
48540 char * kwnames[] = {
48541 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48542 };
48543
48544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48545 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48546 if (!SWIG_IsOK(res1)) {
48547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48548 }
48549 ecode2 = SWIG_AsVal_int(obj1, &val2);
48550 if (!SWIG_IsOK(ecode2)) {
48551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48552 }
48553 arg2 = static_cast< int >(val2);
48554 ecode3 = SWIG_AsVal_int(obj2, &val3);
48555 if (!SWIG_IsOK(ecode3)) {
48556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48557 }
48558 arg3 = static_cast< int >(val3);
48559 ecode4 = SWIG_AsVal_int(obj3, &val4);
48560 if (!SWIG_IsOK(ecode4)) {
48561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48562 }
48563 arg4 = static_cast< int >(val4);
48564 if (obj4) {
48565 arg5 = obj4;
48566 }
48567 {
48568 PyThreadState* __tstate = wxPyBeginAllowThreads();
48569 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48570 wxPyEndAllowThreads(__tstate);
48571 if (PyErr_Occurred()) SWIG_fail;
48572 }
48573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48574 return resultobj;
48575 fail:
48576 return NULL;
48577 }
48578
48579
48580 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48581 PyObject *resultobj = 0;
48582 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48583 void *argp1 = 0 ;
48584 int res1 = 0 ;
48585 PyObject *swig_obj[1] ;
48586
48587 if (!args) SWIG_fail;
48588 swig_obj[0] = args;
48589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48590 if (!SWIG_IsOK(res1)) {
48591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48592 }
48593 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48594 {
48595 PyThreadState* __tstate = wxPyBeginAllowThreads();
48596 (arg1)->DeleteWindows();
48597 wxPyEndAllowThreads(__tstate);
48598 if (PyErr_Occurred()) SWIG_fail;
48599 }
48600 resultobj = SWIG_Py_Void();
48601 return resultobj;
48602 fail:
48603 return NULL;
48604 }
48605
48606
48607 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48608 PyObject *resultobj = 0;
48609 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48610 void *argp1 = 0 ;
48611 int res1 = 0 ;
48612 PyObject *swig_obj[1] ;
48613
48614 if (!args) SWIG_fail;
48615 swig_obj[0] = args;
48616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48617 if (!SWIG_IsOK(res1)) {
48618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48619 }
48620 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48621 {
48622 PyThreadState* __tstate = wxPyBeginAllowThreads();
48623 (arg1)->DetachSizer();
48624 wxPyEndAllowThreads(__tstate);
48625 if (PyErr_Occurred()) SWIG_fail;
48626 }
48627 resultobj = SWIG_Py_Void();
48628 return resultobj;
48629 fail:
48630 return NULL;
48631 }
48632
48633
48634 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48635 PyObject *resultobj = 0;
48636 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48637 wxSize result;
48638 void *argp1 = 0 ;
48639 int res1 = 0 ;
48640 PyObject *swig_obj[1] ;
48641
48642 if (!args) SWIG_fail;
48643 swig_obj[0] = args;
48644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48645 if (!SWIG_IsOK(res1)) {
48646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48647 }
48648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48649 {
48650 PyThreadState* __tstate = wxPyBeginAllowThreads();
48651 result = (arg1)->GetSize();
48652 wxPyEndAllowThreads(__tstate);
48653 if (PyErr_Occurred()) SWIG_fail;
48654 }
48655 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48656 return resultobj;
48657 fail:
48658 return NULL;
48659 }
48660
48661
48662 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48663 PyObject *resultobj = 0;
48664 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48665 wxSize result;
48666 void *argp1 = 0 ;
48667 int res1 = 0 ;
48668 PyObject *swig_obj[1] ;
48669
48670 if (!args) SWIG_fail;
48671 swig_obj[0] = args;
48672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48673 if (!SWIG_IsOK(res1)) {
48674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48675 }
48676 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48677 {
48678 PyThreadState* __tstate = wxPyBeginAllowThreads();
48679 result = (arg1)->CalcMin();
48680 wxPyEndAllowThreads(__tstate);
48681 if (PyErr_Occurred()) SWIG_fail;
48682 }
48683 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48684 return resultobj;
48685 fail:
48686 return NULL;
48687 }
48688
48689
48690 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48691 PyObject *resultobj = 0;
48692 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48693 wxPoint *arg2 = 0 ;
48694 wxSize *arg3 = 0 ;
48695 void *argp1 = 0 ;
48696 int res1 = 0 ;
48697 wxPoint temp2 ;
48698 wxSize temp3 ;
48699 PyObject * obj0 = 0 ;
48700 PyObject * obj1 = 0 ;
48701 PyObject * obj2 = 0 ;
48702 char * kwnames[] = {
48703 (char *) "self",(char *) "pos",(char *) "size", NULL
48704 };
48705
48706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48708 if (!SWIG_IsOK(res1)) {
48709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48710 }
48711 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48712 {
48713 arg2 = &temp2;
48714 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48715 }
48716 {
48717 arg3 = &temp3;
48718 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48719 }
48720 {
48721 PyThreadState* __tstate = wxPyBeginAllowThreads();
48722 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48723 wxPyEndAllowThreads(__tstate);
48724 if (PyErr_Occurred()) SWIG_fail;
48725 }
48726 resultobj = SWIG_Py_Void();
48727 return resultobj;
48728 fail:
48729 return NULL;
48730 }
48731
48732
48733 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48734 PyObject *resultobj = 0;
48735 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48736 wxSize result;
48737 void *argp1 = 0 ;
48738 int res1 = 0 ;
48739 PyObject *swig_obj[1] ;
48740
48741 if (!args) SWIG_fail;
48742 swig_obj[0] = args;
48743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48744 if (!SWIG_IsOK(res1)) {
48745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48746 }
48747 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48748 {
48749 PyThreadState* __tstate = wxPyBeginAllowThreads();
48750 result = (arg1)->GetMinSize();
48751 wxPyEndAllowThreads(__tstate);
48752 if (PyErr_Occurred()) SWIG_fail;
48753 }
48754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48755 return resultobj;
48756 fail:
48757 return NULL;
48758 }
48759
48760
48761 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48762 PyObject *resultobj = 0;
48763 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48764 wxSize result;
48765 void *argp1 = 0 ;
48766 int res1 = 0 ;
48767 PyObject *swig_obj[1] ;
48768
48769 if (!args) SWIG_fail;
48770 swig_obj[0] = args;
48771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48772 if (!SWIG_IsOK(res1)) {
48773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48774 }
48775 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48776 {
48777 PyThreadState* __tstate = wxPyBeginAllowThreads();
48778 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48779 wxPyEndAllowThreads(__tstate);
48780 if (PyErr_Occurred()) SWIG_fail;
48781 }
48782 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48783 return resultobj;
48784 fail:
48785 return NULL;
48786 }
48787
48788
48789 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48790 PyObject *resultobj = 0;
48791 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48792 int arg2 ;
48793 int arg3 ;
48794 void *argp1 = 0 ;
48795 int res1 = 0 ;
48796 int val2 ;
48797 int ecode2 = 0 ;
48798 int val3 ;
48799 int ecode3 = 0 ;
48800 PyObject * obj0 = 0 ;
48801 PyObject * obj1 = 0 ;
48802 PyObject * obj2 = 0 ;
48803 char * kwnames[] = {
48804 (char *) "self",(char *) "x",(char *) "y", NULL
48805 };
48806
48807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48809 if (!SWIG_IsOK(res1)) {
48810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48811 }
48812 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48813 ecode2 = SWIG_AsVal_int(obj1, &val2);
48814 if (!SWIG_IsOK(ecode2)) {
48815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48816 }
48817 arg2 = static_cast< int >(val2);
48818 ecode3 = SWIG_AsVal_int(obj2, &val3);
48819 if (!SWIG_IsOK(ecode3)) {
48820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48821 }
48822 arg3 = static_cast< int >(val3);
48823 {
48824 PyThreadState* __tstate = wxPyBeginAllowThreads();
48825 (arg1)->SetInitSize(arg2,arg3);
48826 wxPyEndAllowThreads(__tstate);
48827 if (PyErr_Occurred()) SWIG_fail;
48828 }
48829 resultobj = SWIG_Py_Void();
48830 return resultobj;
48831 fail:
48832 return NULL;
48833 }
48834
48835
48836 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48837 PyObject *resultobj = 0;
48838 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48839 int arg2 ;
48840 int arg3 ;
48841 void *argp1 = 0 ;
48842 int res1 = 0 ;
48843 int val2 ;
48844 int ecode2 = 0 ;
48845 int val3 ;
48846 int ecode3 = 0 ;
48847 PyObject * obj0 = 0 ;
48848 PyObject * obj1 = 0 ;
48849 PyObject * obj2 = 0 ;
48850 char * kwnames[] = {
48851 (char *) "self",(char *) "width",(char *) "height", NULL
48852 };
48853
48854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48856 if (!SWIG_IsOK(res1)) {
48857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48858 }
48859 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48860 ecode2 = SWIG_AsVal_int(obj1, &val2);
48861 if (!SWIG_IsOK(ecode2)) {
48862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48863 }
48864 arg2 = static_cast< int >(val2);
48865 ecode3 = SWIG_AsVal_int(obj2, &val3);
48866 if (!SWIG_IsOK(ecode3)) {
48867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48868 }
48869 arg3 = static_cast< int >(val3);
48870 {
48871 PyThreadState* __tstate = wxPyBeginAllowThreads();
48872 (arg1)->SetRatio(arg2,arg3);
48873 wxPyEndAllowThreads(__tstate);
48874 if (PyErr_Occurred()) SWIG_fail;
48875 }
48876 resultobj = SWIG_Py_Void();
48877 return resultobj;
48878 fail:
48879 return NULL;
48880 }
48881
48882
48883 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48884 PyObject *resultobj = 0;
48885 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48886 wxSize *arg2 = 0 ;
48887 void *argp1 = 0 ;
48888 int res1 = 0 ;
48889 wxSize temp2 ;
48890 PyObject * obj0 = 0 ;
48891 PyObject * obj1 = 0 ;
48892 char * kwnames[] = {
48893 (char *) "self",(char *) "size", NULL
48894 };
48895
48896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48898 if (!SWIG_IsOK(res1)) {
48899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48900 }
48901 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48902 {
48903 arg2 = &temp2;
48904 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48905 }
48906 {
48907 PyThreadState* __tstate = wxPyBeginAllowThreads();
48908 (arg1)->SetRatio((wxSize const &)*arg2);
48909 wxPyEndAllowThreads(__tstate);
48910 if (PyErr_Occurred()) SWIG_fail;
48911 }
48912 resultobj = SWIG_Py_Void();
48913 return resultobj;
48914 fail:
48915 return NULL;
48916 }
48917
48918
48919 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48920 PyObject *resultobj = 0;
48921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48922 float arg2 ;
48923 void *argp1 = 0 ;
48924 int res1 = 0 ;
48925 float val2 ;
48926 int ecode2 = 0 ;
48927 PyObject * obj0 = 0 ;
48928 PyObject * obj1 = 0 ;
48929 char * kwnames[] = {
48930 (char *) "self",(char *) "ratio", NULL
48931 };
48932
48933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48935 if (!SWIG_IsOK(res1)) {
48936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48937 }
48938 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48939 ecode2 = SWIG_AsVal_float(obj1, &val2);
48940 if (!SWIG_IsOK(ecode2)) {
48941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48942 }
48943 arg2 = static_cast< float >(val2);
48944 {
48945 PyThreadState* __tstate = wxPyBeginAllowThreads();
48946 (arg1)->SetRatio(arg2);
48947 wxPyEndAllowThreads(__tstate);
48948 if (PyErr_Occurred()) SWIG_fail;
48949 }
48950 resultobj = SWIG_Py_Void();
48951 return resultobj;
48952 fail:
48953 return NULL;
48954 }
48955
48956
48957 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48958 PyObject *resultobj = 0;
48959 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48960 float result;
48961 void *argp1 = 0 ;
48962 int res1 = 0 ;
48963 PyObject *swig_obj[1] ;
48964
48965 if (!args) SWIG_fail;
48966 swig_obj[0] = args;
48967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48968 if (!SWIG_IsOK(res1)) {
48969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48970 }
48971 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48972 {
48973 PyThreadState* __tstate = wxPyBeginAllowThreads();
48974 result = (float)(arg1)->GetRatio();
48975 wxPyEndAllowThreads(__tstate);
48976 if (PyErr_Occurred()) SWIG_fail;
48977 }
48978 resultobj = SWIG_From_float(static_cast< float >(result));
48979 return resultobj;
48980 fail:
48981 return NULL;
48982 }
48983
48984
48985 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48986 PyObject *resultobj = 0;
48987 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48988 wxRect result;
48989 void *argp1 = 0 ;
48990 int res1 = 0 ;
48991 PyObject *swig_obj[1] ;
48992
48993 if (!args) SWIG_fail;
48994 swig_obj[0] = args;
48995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48996 if (!SWIG_IsOK(res1)) {
48997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48998 }
48999 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49000 {
49001 PyThreadState* __tstate = wxPyBeginAllowThreads();
49002 result = (arg1)->GetRect();
49003 wxPyEndAllowThreads(__tstate);
49004 if (PyErr_Occurred()) SWIG_fail;
49005 }
49006 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49007 return resultobj;
49008 fail:
49009 return NULL;
49010 }
49011
49012
49013 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49014 PyObject *resultobj = 0;
49015 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49016 bool result;
49017 void *argp1 = 0 ;
49018 int res1 = 0 ;
49019 PyObject *swig_obj[1] ;
49020
49021 if (!args) SWIG_fail;
49022 swig_obj[0] = args;
49023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49024 if (!SWIG_IsOK(res1)) {
49025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49026 }
49027 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49028 {
49029 PyThreadState* __tstate = wxPyBeginAllowThreads();
49030 result = (bool)(arg1)->IsWindow();
49031 wxPyEndAllowThreads(__tstate);
49032 if (PyErr_Occurred()) SWIG_fail;
49033 }
49034 {
49035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49036 }
49037 return resultobj;
49038 fail:
49039 return NULL;
49040 }
49041
49042
49043 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49044 PyObject *resultobj = 0;
49045 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49046 bool result;
49047 void *argp1 = 0 ;
49048 int res1 = 0 ;
49049 PyObject *swig_obj[1] ;
49050
49051 if (!args) SWIG_fail;
49052 swig_obj[0] = args;
49053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49054 if (!SWIG_IsOK(res1)) {
49055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49056 }
49057 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49058 {
49059 PyThreadState* __tstate = wxPyBeginAllowThreads();
49060 result = (bool)(arg1)->IsSizer();
49061 wxPyEndAllowThreads(__tstate);
49062 if (PyErr_Occurred()) SWIG_fail;
49063 }
49064 {
49065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49066 }
49067 return resultobj;
49068 fail:
49069 return NULL;
49070 }
49071
49072
49073 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49074 PyObject *resultobj = 0;
49075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49076 bool result;
49077 void *argp1 = 0 ;
49078 int res1 = 0 ;
49079 PyObject *swig_obj[1] ;
49080
49081 if (!args) SWIG_fail;
49082 swig_obj[0] = args;
49083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49084 if (!SWIG_IsOK(res1)) {
49085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49086 }
49087 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49088 {
49089 PyThreadState* __tstate = wxPyBeginAllowThreads();
49090 result = (bool)(arg1)->IsSpacer();
49091 wxPyEndAllowThreads(__tstate);
49092 if (PyErr_Occurred()) SWIG_fail;
49093 }
49094 {
49095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49096 }
49097 return resultobj;
49098 fail:
49099 return NULL;
49100 }
49101
49102
49103 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49104 PyObject *resultobj = 0;
49105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49106 int arg2 ;
49107 void *argp1 = 0 ;
49108 int res1 = 0 ;
49109 int val2 ;
49110 int ecode2 = 0 ;
49111 PyObject * obj0 = 0 ;
49112 PyObject * obj1 = 0 ;
49113 char * kwnames[] = {
49114 (char *) "self",(char *) "proportion", NULL
49115 };
49116
49117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49119 if (!SWIG_IsOK(res1)) {
49120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49121 }
49122 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49123 ecode2 = SWIG_AsVal_int(obj1, &val2);
49124 if (!SWIG_IsOK(ecode2)) {
49125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49126 }
49127 arg2 = static_cast< int >(val2);
49128 {
49129 PyThreadState* __tstate = wxPyBeginAllowThreads();
49130 (arg1)->SetProportion(arg2);
49131 wxPyEndAllowThreads(__tstate);
49132 if (PyErr_Occurred()) SWIG_fail;
49133 }
49134 resultobj = SWIG_Py_Void();
49135 return resultobj;
49136 fail:
49137 return NULL;
49138 }
49139
49140
49141 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49142 PyObject *resultobj = 0;
49143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49144 int result;
49145 void *argp1 = 0 ;
49146 int res1 = 0 ;
49147 PyObject *swig_obj[1] ;
49148
49149 if (!args) SWIG_fail;
49150 swig_obj[0] = args;
49151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49152 if (!SWIG_IsOK(res1)) {
49153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49154 }
49155 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49156 {
49157 PyThreadState* __tstate = wxPyBeginAllowThreads();
49158 result = (int)(arg1)->GetProportion();
49159 wxPyEndAllowThreads(__tstate);
49160 if (PyErr_Occurred()) SWIG_fail;
49161 }
49162 resultobj = SWIG_From_int(static_cast< int >(result));
49163 return resultobj;
49164 fail:
49165 return NULL;
49166 }
49167
49168
49169 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49170 PyObject *resultobj = 0;
49171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49172 int arg2 ;
49173 void *argp1 = 0 ;
49174 int res1 = 0 ;
49175 int val2 ;
49176 int ecode2 = 0 ;
49177 PyObject * obj0 = 0 ;
49178 PyObject * obj1 = 0 ;
49179 char * kwnames[] = {
49180 (char *) "self",(char *) "flag", NULL
49181 };
49182
49183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49185 if (!SWIG_IsOK(res1)) {
49186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49187 }
49188 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49189 ecode2 = SWIG_AsVal_int(obj1, &val2);
49190 if (!SWIG_IsOK(ecode2)) {
49191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49192 }
49193 arg2 = static_cast< int >(val2);
49194 {
49195 PyThreadState* __tstate = wxPyBeginAllowThreads();
49196 (arg1)->SetFlag(arg2);
49197 wxPyEndAllowThreads(__tstate);
49198 if (PyErr_Occurred()) SWIG_fail;
49199 }
49200 resultobj = SWIG_Py_Void();
49201 return resultobj;
49202 fail:
49203 return NULL;
49204 }
49205
49206
49207 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49208 PyObject *resultobj = 0;
49209 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49210 int result;
49211 void *argp1 = 0 ;
49212 int res1 = 0 ;
49213 PyObject *swig_obj[1] ;
49214
49215 if (!args) SWIG_fail;
49216 swig_obj[0] = args;
49217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49218 if (!SWIG_IsOK(res1)) {
49219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49220 }
49221 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49222 {
49223 PyThreadState* __tstate = wxPyBeginAllowThreads();
49224 result = (int)(arg1)->GetFlag();
49225 wxPyEndAllowThreads(__tstate);
49226 if (PyErr_Occurred()) SWIG_fail;
49227 }
49228 resultobj = SWIG_From_int(static_cast< int >(result));
49229 return resultobj;
49230 fail:
49231 return NULL;
49232 }
49233
49234
49235 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49236 PyObject *resultobj = 0;
49237 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49238 int arg2 ;
49239 void *argp1 = 0 ;
49240 int res1 = 0 ;
49241 int val2 ;
49242 int ecode2 = 0 ;
49243 PyObject * obj0 = 0 ;
49244 PyObject * obj1 = 0 ;
49245 char * kwnames[] = {
49246 (char *) "self",(char *) "border", NULL
49247 };
49248
49249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49251 if (!SWIG_IsOK(res1)) {
49252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49253 }
49254 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49255 ecode2 = SWIG_AsVal_int(obj1, &val2);
49256 if (!SWIG_IsOK(ecode2)) {
49257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49258 }
49259 arg2 = static_cast< int >(val2);
49260 {
49261 PyThreadState* __tstate = wxPyBeginAllowThreads();
49262 (arg1)->SetBorder(arg2);
49263 wxPyEndAllowThreads(__tstate);
49264 if (PyErr_Occurred()) SWIG_fail;
49265 }
49266 resultobj = SWIG_Py_Void();
49267 return resultobj;
49268 fail:
49269 return NULL;
49270 }
49271
49272
49273 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49274 PyObject *resultobj = 0;
49275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49276 int result;
49277 void *argp1 = 0 ;
49278 int res1 = 0 ;
49279 PyObject *swig_obj[1] ;
49280
49281 if (!args) SWIG_fail;
49282 swig_obj[0] = args;
49283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49284 if (!SWIG_IsOK(res1)) {
49285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49286 }
49287 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49288 {
49289 PyThreadState* __tstate = wxPyBeginAllowThreads();
49290 result = (int)(arg1)->GetBorder();
49291 wxPyEndAllowThreads(__tstate);
49292 if (PyErr_Occurred()) SWIG_fail;
49293 }
49294 resultobj = SWIG_From_int(static_cast< int >(result));
49295 return resultobj;
49296 fail:
49297 return NULL;
49298 }
49299
49300
49301 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49302 PyObject *resultobj = 0;
49303 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49304 wxWindow *result = 0 ;
49305 void *argp1 = 0 ;
49306 int res1 = 0 ;
49307 PyObject *swig_obj[1] ;
49308
49309 if (!args) SWIG_fail;
49310 swig_obj[0] = args;
49311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49312 if (!SWIG_IsOK(res1)) {
49313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49314 }
49315 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49316 {
49317 PyThreadState* __tstate = wxPyBeginAllowThreads();
49318 result = (wxWindow *)(arg1)->GetWindow();
49319 wxPyEndAllowThreads(__tstate);
49320 if (PyErr_Occurred()) SWIG_fail;
49321 }
49322 {
49323 resultobj = wxPyMake_wxObject(result, 0);
49324 }
49325 return resultobj;
49326 fail:
49327 return NULL;
49328 }
49329
49330
49331 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49332 PyObject *resultobj = 0;
49333 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49334 wxWindow *arg2 = (wxWindow *) 0 ;
49335 void *argp1 = 0 ;
49336 int res1 = 0 ;
49337 void *argp2 = 0 ;
49338 int res2 = 0 ;
49339 PyObject * obj0 = 0 ;
49340 PyObject * obj1 = 0 ;
49341 char * kwnames[] = {
49342 (char *) "self",(char *) "window", NULL
49343 };
49344
49345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49347 if (!SWIG_IsOK(res1)) {
49348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49349 }
49350 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49352 if (!SWIG_IsOK(res2)) {
49353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49354 }
49355 arg2 = reinterpret_cast< wxWindow * >(argp2);
49356 {
49357 PyThreadState* __tstate = wxPyBeginAllowThreads();
49358 (arg1)->SetWindow(arg2);
49359 wxPyEndAllowThreads(__tstate);
49360 if (PyErr_Occurred()) SWIG_fail;
49361 }
49362 resultobj = SWIG_Py_Void();
49363 return resultobj;
49364 fail:
49365 return NULL;
49366 }
49367
49368
49369 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49370 PyObject *resultobj = 0;
49371 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49372 wxSizer *result = 0 ;
49373 void *argp1 = 0 ;
49374 int res1 = 0 ;
49375 PyObject *swig_obj[1] ;
49376
49377 if (!args) SWIG_fail;
49378 swig_obj[0] = args;
49379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49380 if (!SWIG_IsOK(res1)) {
49381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49382 }
49383 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49384 {
49385 PyThreadState* __tstate = wxPyBeginAllowThreads();
49386 result = (wxSizer *)(arg1)->GetSizer();
49387 wxPyEndAllowThreads(__tstate);
49388 if (PyErr_Occurred()) SWIG_fail;
49389 }
49390 {
49391 resultobj = wxPyMake_wxObject(result, (bool)0);
49392 }
49393 return resultobj;
49394 fail:
49395 return NULL;
49396 }
49397
49398
49399 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49400 PyObject *resultobj = 0;
49401 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49402 wxSizer *arg2 = (wxSizer *) 0 ;
49403 void *argp1 = 0 ;
49404 int res1 = 0 ;
49405 int res2 = 0 ;
49406 PyObject * obj0 = 0 ;
49407 PyObject * obj1 = 0 ;
49408 char * kwnames[] = {
49409 (char *) "self",(char *) "sizer", NULL
49410 };
49411
49412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49414 if (!SWIG_IsOK(res1)) {
49415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49416 }
49417 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49418 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49419 if (!SWIG_IsOK(res2)) {
49420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49421 }
49422 {
49423 PyThreadState* __tstate = wxPyBeginAllowThreads();
49424 (arg1)->SetSizer(arg2);
49425 wxPyEndAllowThreads(__tstate);
49426 if (PyErr_Occurred()) SWIG_fail;
49427 }
49428 resultobj = SWIG_Py_Void();
49429 return resultobj;
49430 fail:
49431 return NULL;
49432 }
49433
49434
49435 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49436 PyObject *resultobj = 0;
49437 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49438 wxSize result;
49439 void *argp1 = 0 ;
49440 int res1 = 0 ;
49441 PyObject *swig_obj[1] ;
49442
49443 if (!args) SWIG_fail;
49444 swig_obj[0] = args;
49445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49446 if (!SWIG_IsOK(res1)) {
49447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49448 }
49449 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49450 {
49451 PyThreadState* __tstate = wxPyBeginAllowThreads();
49452 result = (arg1)->GetSpacer();
49453 wxPyEndAllowThreads(__tstate);
49454 if (PyErr_Occurred()) SWIG_fail;
49455 }
49456 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49457 return resultobj;
49458 fail:
49459 return NULL;
49460 }
49461
49462
49463 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49464 PyObject *resultobj = 0;
49465 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49466 wxSize *arg2 = 0 ;
49467 void *argp1 = 0 ;
49468 int res1 = 0 ;
49469 wxSize temp2 ;
49470 PyObject * obj0 = 0 ;
49471 PyObject * obj1 = 0 ;
49472 char * kwnames[] = {
49473 (char *) "self",(char *) "size", NULL
49474 };
49475
49476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49478 if (!SWIG_IsOK(res1)) {
49479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49480 }
49481 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49482 {
49483 arg2 = &temp2;
49484 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49485 }
49486 {
49487 PyThreadState* __tstate = wxPyBeginAllowThreads();
49488 (arg1)->SetSpacer((wxSize const &)*arg2);
49489 wxPyEndAllowThreads(__tstate);
49490 if (PyErr_Occurred()) SWIG_fail;
49491 }
49492 resultobj = SWIG_Py_Void();
49493 return resultobj;
49494 fail:
49495 return NULL;
49496 }
49497
49498
49499 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49500 PyObject *resultobj = 0;
49501 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49502 bool arg2 ;
49503 void *argp1 = 0 ;
49504 int res1 = 0 ;
49505 bool val2 ;
49506 int ecode2 = 0 ;
49507 PyObject * obj0 = 0 ;
49508 PyObject * obj1 = 0 ;
49509 char * kwnames[] = {
49510 (char *) "self",(char *) "show", NULL
49511 };
49512
49513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49515 if (!SWIG_IsOK(res1)) {
49516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49517 }
49518 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49519 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49520 if (!SWIG_IsOK(ecode2)) {
49521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49522 }
49523 arg2 = static_cast< bool >(val2);
49524 {
49525 PyThreadState* __tstate = wxPyBeginAllowThreads();
49526 (arg1)->Show(arg2);
49527 wxPyEndAllowThreads(__tstate);
49528 if (PyErr_Occurred()) SWIG_fail;
49529 }
49530 resultobj = SWIG_Py_Void();
49531 return resultobj;
49532 fail:
49533 return NULL;
49534 }
49535
49536
49537 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49538 PyObject *resultobj = 0;
49539 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49540 bool result;
49541 void *argp1 = 0 ;
49542 int res1 = 0 ;
49543 PyObject *swig_obj[1] ;
49544
49545 if (!args) SWIG_fail;
49546 swig_obj[0] = args;
49547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49548 if (!SWIG_IsOK(res1)) {
49549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49550 }
49551 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49552 {
49553 PyThreadState* __tstate = wxPyBeginAllowThreads();
49554 result = (bool)(arg1)->IsShown();
49555 wxPyEndAllowThreads(__tstate);
49556 if (PyErr_Occurred()) SWIG_fail;
49557 }
49558 {
49559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49560 }
49561 return resultobj;
49562 fail:
49563 return NULL;
49564 }
49565
49566
49567 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49568 PyObject *resultobj = 0;
49569 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49570 wxPoint result;
49571 void *argp1 = 0 ;
49572 int res1 = 0 ;
49573 PyObject *swig_obj[1] ;
49574
49575 if (!args) SWIG_fail;
49576 swig_obj[0] = args;
49577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49578 if (!SWIG_IsOK(res1)) {
49579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49580 }
49581 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49582 {
49583 PyThreadState* __tstate = wxPyBeginAllowThreads();
49584 result = (arg1)->GetPosition();
49585 wxPyEndAllowThreads(__tstate);
49586 if (PyErr_Occurred()) SWIG_fail;
49587 }
49588 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49589 return resultobj;
49590 fail:
49591 return NULL;
49592 }
49593
49594
49595 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49596 PyObject *resultobj = 0;
49597 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49598 PyObject *result = 0 ;
49599 void *argp1 = 0 ;
49600 int res1 = 0 ;
49601 PyObject *swig_obj[1] ;
49602
49603 if (!args) SWIG_fail;
49604 swig_obj[0] = args;
49605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49606 if (!SWIG_IsOK(res1)) {
49607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49608 }
49609 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49610 {
49611 PyThreadState* __tstate = wxPyBeginAllowThreads();
49612 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49613 wxPyEndAllowThreads(__tstate);
49614 if (PyErr_Occurred()) SWIG_fail;
49615 }
49616 resultobj = result;
49617 return resultobj;
49618 fail:
49619 return NULL;
49620 }
49621
49622
49623 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49624 PyObject *resultobj = 0;
49625 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49626 PyObject *arg2 = (PyObject *) 0 ;
49627 void *argp1 = 0 ;
49628 int res1 = 0 ;
49629 PyObject * obj0 = 0 ;
49630 PyObject * obj1 = 0 ;
49631 char * kwnames[] = {
49632 (char *) "self",(char *) "userData", NULL
49633 };
49634
49635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49637 if (!SWIG_IsOK(res1)) {
49638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49639 }
49640 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49641 arg2 = obj1;
49642 {
49643 PyThreadState* __tstate = wxPyBeginAllowThreads();
49644 wxSizerItem_SetUserData(arg1,arg2);
49645 wxPyEndAllowThreads(__tstate);
49646 if (PyErr_Occurred()) SWIG_fail;
49647 }
49648 resultobj = SWIG_Py_Void();
49649 return resultobj;
49650 fail:
49651 return NULL;
49652 }
49653
49654
49655 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49656 PyObject *obj;
49657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49658 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49659 return SWIG_Py_Void();
49660 }
49661
49662 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49663 return SWIG_Python_InitShadowInstance(args);
49664 }
49665
49666 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49667 PyObject *resultobj = 0;
49668 wxSizer *arg1 = (wxSizer *) 0 ;
49669 void *argp1 = 0 ;
49670 int res1 = 0 ;
49671 PyObject *swig_obj[1] ;
49672
49673 if (!args) SWIG_fail;
49674 swig_obj[0] = args;
49675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49676 if (!SWIG_IsOK(res1)) {
49677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49678 }
49679 arg1 = reinterpret_cast< wxSizer * >(argp1);
49680 {
49681 PyThreadState* __tstate = wxPyBeginAllowThreads();
49682 delete arg1;
49683
49684 wxPyEndAllowThreads(__tstate);
49685 if (PyErr_Occurred()) SWIG_fail;
49686 }
49687 resultobj = SWIG_Py_Void();
49688 return resultobj;
49689 fail:
49690 return NULL;
49691 }
49692
49693
49694 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49695 PyObject *resultobj = 0;
49696 wxSizer *arg1 = (wxSizer *) 0 ;
49697 PyObject *arg2 = (PyObject *) 0 ;
49698 void *argp1 = 0 ;
49699 int res1 = 0 ;
49700 PyObject * obj0 = 0 ;
49701 PyObject * obj1 = 0 ;
49702 char * kwnames[] = {
49703 (char *) "self",(char *) "_self", NULL
49704 };
49705
49706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49708 if (!SWIG_IsOK(res1)) {
49709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49710 }
49711 arg1 = reinterpret_cast< wxSizer * >(argp1);
49712 arg2 = obj1;
49713 {
49714 PyThreadState* __tstate = wxPyBeginAllowThreads();
49715 wxSizer__setOORInfo(arg1,arg2);
49716 wxPyEndAllowThreads(__tstate);
49717 if (PyErr_Occurred()) SWIG_fail;
49718 }
49719 resultobj = SWIG_Py_Void();
49720 return resultobj;
49721 fail:
49722 return NULL;
49723 }
49724
49725
49726 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49727 PyObject *resultobj = 0;
49728 wxSizer *arg1 = (wxSizer *) 0 ;
49729 PyObject *arg2 = (PyObject *) 0 ;
49730 int arg3 = (int) 0 ;
49731 int arg4 = (int) 0 ;
49732 int arg5 = (int) 0 ;
49733 PyObject *arg6 = (PyObject *) NULL ;
49734 wxSizerItem *result = 0 ;
49735 void *argp1 = 0 ;
49736 int res1 = 0 ;
49737 int val3 ;
49738 int ecode3 = 0 ;
49739 int val4 ;
49740 int ecode4 = 0 ;
49741 int val5 ;
49742 int ecode5 = 0 ;
49743 PyObject * obj0 = 0 ;
49744 PyObject * obj1 = 0 ;
49745 PyObject * obj2 = 0 ;
49746 PyObject * obj3 = 0 ;
49747 PyObject * obj4 = 0 ;
49748 PyObject * obj5 = 0 ;
49749 char * kwnames[] = {
49750 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49751 };
49752
49753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49755 if (!SWIG_IsOK(res1)) {
49756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49757 }
49758 arg1 = reinterpret_cast< wxSizer * >(argp1);
49759 arg2 = obj1;
49760 if (obj2) {
49761 ecode3 = SWIG_AsVal_int(obj2, &val3);
49762 if (!SWIG_IsOK(ecode3)) {
49763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49764 }
49765 arg3 = static_cast< int >(val3);
49766 }
49767 if (obj3) {
49768 ecode4 = SWIG_AsVal_int(obj3, &val4);
49769 if (!SWIG_IsOK(ecode4)) {
49770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49771 }
49772 arg4 = static_cast< int >(val4);
49773 }
49774 if (obj4) {
49775 ecode5 = SWIG_AsVal_int(obj4, &val5);
49776 if (!SWIG_IsOK(ecode5)) {
49777 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49778 }
49779 arg5 = static_cast< int >(val5);
49780 }
49781 if (obj5) {
49782 arg6 = obj5;
49783 }
49784 {
49785 PyThreadState* __tstate = wxPyBeginAllowThreads();
49786 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49787 wxPyEndAllowThreads(__tstate);
49788 if (PyErr_Occurred()) SWIG_fail;
49789 }
49790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49791 return resultobj;
49792 fail:
49793 return NULL;
49794 }
49795
49796
49797 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49798 PyObject *resultobj = 0;
49799 wxSizer *arg1 = (wxSizer *) 0 ;
49800 int arg2 ;
49801 PyObject *arg3 = (PyObject *) 0 ;
49802 int arg4 = (int) 0 ;
49803 int arg5 = (int) 0 ;
49804 int arg6 = (int) 0 ;
49805 PyObject *arg7 = (PyObject *) NULL ;
49806 wxSizerItem *result = 0 ;
49807 void *argp1 = 0 ;
49808 int res1 = 0 ;
49809 int val2 ;
49810 int ecode2 = 0 ;
49811 int val4 ;
49812 int ecode4 = 0 ;
49813 int val5 ;
49814 int ecode5 = 0 ;
49815 int val6 ;
49816 int ecode6 = 0 ;
49817 PyObject * obj0 = 0 ;
49818 PyObject * obj1 = 0 ;
49819 PyObject * obj2 = 0 ;
49820 PyObject * obj3 = 0 ;
49821 PyObject * obj4 = 0 ;
49822 PyObject * obj5 = 0 ;
49823 PyObject * obj6 = 0 ;
49824 char * kwnames[] = {
49825 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49826 };
49827
49828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49830 if (!SWIG_IsOK(res1)) {
49831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49832 }
49833 arg1 = reinterpret_cast< wxSizer * >(argp1);
49834 ecode2 = SWIG_AsVal_int(obj1, &val2);
49835 if (!SWIG_IsOK(ecode2)) {
49836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49837 }
49838 arg2 = static_cast< int >(val2);
49839 arg3 = obj2;
49840 if (obj3) {
49841 ecode4 = SWIG_AsVal_int(obj3, &val4);
49842 if (!SWIG_IsOK(ecode4)) {
49843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49844 }
49845 arg4 = static_cast< int >(val4);
49846 }
49847 if (obj4) {
49848 ecode5 = SWIG_AsVal_int(obj4, &val5);
49849 if (!SWIG_IsOK(ecode5)) {
49850 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49851 }
49852 arg5 = static_cast< int >(val5);
49853 }
49854 if (obj5) {
49855 ecode6 = SWIG_AsVal_int(obj5, &val6);
49856 if (!SWIG_IsOK(ecode6)) {
49857 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49858 }
49859 arg6 = static_cast< int >(val6);
49860 }
49861 if (obj6) {
49862 arg7 = obj6;
49863 }
49864 {
49865 PyThreadState* __tstate = wxPyBeginAllowThreads();
49866 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49867 wxPyEndAllowThreads(__tstate);
49868 if (PyErr_Occurred()) SWIG_fail;
49869 }
49870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49871 return resultobj;
49872 fail:
49873 return NULL;
49874 }
49875
49876
49877 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49878 PyObject *resultobj = 0;
49879 wxSizer *arg1 = (wxSizer *) 0 ;
49880 PyObject *arg2 = (PyObject *) 0 ;
49881 int arg3 = (int) 0 ;
49882 int arg4 = (int) 0 ;
49883 int arg5 = (int) 0 ;
49884 PyObject *arg6 = (PyObject *) NULL ;
49885 wxSizerItem *result = 0 ;
49886 void *argp1 = 0 ;
49887 int res1 = 0 ;
49888 int val3 ;
49889 int ecode3 = 0 ;
49890 int val4 ;
49891 int ecode4 = 0 ;
49892 int val5 ;
49893 int ecode5 = 0 ;
49894 PyObject * obj0 = 0 ;
49895 PyObject * obj1 = 0 ;
49896 PyObject * obj2 = 0 ;
49897 PyObject * obj3 = 0 ;
49898 PyObject * obj4 = 0 ;
49899 PyObject * obj5 = 0 ;
49900 char * kwnames[] = {
49901 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49902 };
49903
49904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49906 if (!SWIG_IsOK(res1)) {
49907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49908 }
49909 arg1 = reinterpret_cast< wxSizer * >(argp1);
49910 arg2 = obj1;
49911 if (obj2) {
49912 ecode3 = SWIG_AsVal_int(obj2, &val3);
49913 if (!SWIG_IsOK(ecode3)) {
49914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49915 }
49916 arg3 = static_cast< int >(val3);
49917 }
49918 if (obj3) {
49919 ecode4 = SWIG_AsVal_int(obj3, &val4);
49920 if (!SWIG_IsOK(ecode4)) {
49921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49922 }
49923 arg4 = static_cast< int >(val4);
49924 }
49925 if (obj4) {
49926 ecode5 = SWIG_AsVal_int(obj4, &val5);
49927 if (!SWIG_IsOK(ecode5)) {
49928 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49929 }
49930 arg5 = static_cast< int >(val5);
49931 }
49932 if (obj5) {
49933 arg6 = obj5;
49934 }
49935 {
49936 PyThreadState* __tstate = wxPyBeginAllowThreads();
49937 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49938 wxPyEndAllowThreads(__tstate);
49939 if (PyErr_Occurred()) SWIG_fail;
49940 }
49941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49942 return resultobj;
49943 fail:
49944 return NULL;
49945 }
49946
49947
49948 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49949 PyObject *resultobj = 0;
49950 wxSizer *arg1 = (wxSizer *) 0 ;
49951 PyObject *arg2 = (PyObject *) 0 ;
49952 bool result;
49953 void *argp1 = 0 ;
49954 int res1 = 0 ;
49955 PyObject * obj0 = 0 ;
49956 PyObject * obj1 = 0 ;
49957 char * kwnames[] = {
49958 (char *) "self",(char *) "item", NULL
49959 };
49960
49961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
49962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49963 if (!SWIG_IsOK(res1)) {
49964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
49965 }
49966 arg1 = reinterpret_cast< wxSizer * >(argp1);
49967 arg2 = obj1;
49968 {
49969 PyThreadState* __tstate = wxPyBeginAllowThreads();
49970 result = (bool)wxSizer_Remove(arg1,arg2);
49971 wxPyEndAllowThreads(__tstate);
49972 if (PyErr_Occurred()) SWIG_fail;
49973 }
49974 {
49975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49976 }
49977 return resultobj;
49978 fail:
49979 return NULL;
49980 }
49981
49982
49983 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49984 PyObject *resultobj = 0;
49985 wxSizer *arg1 = (wxSizer *) 0 ;
49986 PyObject *arg2 = (PyObject *) 0 ;
49987 bool result;
49988 void *argp1 = 0 ;
49989 int res1 = 0 ;
49990 PyObject * obj0 = 0 ;
49991 PyObject * obj1 = 0 ;
49992 char * kwnames[] = {
49993 (char *) "self",(char *) "item", NULL
49994 };
49995
49996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
49997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49998 if (!SWIG_IsOK(res1)) {
49999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50000 }
50001 arg1 = reinterpret_cast< wxSizer * >(argp1);
50002 arg2 = obj1;
50003 {
50004 PyThreadState* __tstate = wxPyBeginAllowThreads();
50005 result = (bool)wxSizer_Detach(arg1,arg2);
50006 wxPyEndAllowThreads(__tstate);
50007 if (PyErr_Occurred()) SWIG_fail;
50008 }
50009 {
50010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50011 }
50012 return resultobj;
50013 fail:
50014 return NULL;
50015 }
50016
50017
50018 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50019 PyObject *resultobj = 0;
50020 wxSizer *arg1 = (wxSizer *) 0 ;
50021 PyObject *arg2 = (PyObject *) 0 ;
50022 wxSizerItem *result = 0 ;
50023 void *argp1 = 0 ;
50024 int res1 = 0 ;
50025 PyObject * obj0 = 0 ;
50026 PyObject * obj1 = 0 ;
50027 char * kwnames[] = {
50028 (char *) "self",(char *) "item", NULL
50029 };
50030
50031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50033 if (!SWIG_IsOK(res1)) {
50034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50035 }
50036 arg1 = reinterpret_cast< wxSizer * >(argp1);
50037 arg2 = obj1;
50038 {
50039 PyThreadState* __tstate = wxPyBeginAllowThreads();
50040 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50041 wxPyEndAllowThreads(__tstate);
50042 if (PyErr_Occurred()) SWIG_fail;
50043 }
50044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50045 return resultobj;
50046 fail:
50047 return NULL;
50048 }
50049
50050
50051 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50052 PyObject *resultobj = 0;
50053 wxSizer *arg1 = (wxSizer *) 0 ;
50054 PyObject *arg2 = (PyObject *) 0 ;
50055 wxSize *arg3 = 0 ;
50056 void *argp1 = 0 ;
50057 int res1 = 0 ;
50058 wxSize temp3 ;
50059 PyObject * obj0 = 0 ;
50060 PyObject * obj1 = 0 ;
50061 PyObject * obj2 = 0 ;
50062 char * kwnames[] = {
50063 (char *) "self",(char *) "item",(char *) "size", NULL
50064 };
50065
50066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50068 if (!SWIG_IsOK(res1)) {
50069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50070 }
50071 arg1 = reinterpret_cast< wxSizer * >(argp1);
50072 arg2 = obj1;
50073 {
50074 arg3 = &temp3;
50075 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50076 }
50077 {
50078 PyThreadState* __tstate = wxPyBeginAllowThreads();
50079 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50080 wxPyEndAllowThreads(__tstate);
50081 if (PyErr_Occurred()) SWIG_fail;
50082 }
50083 resultobj = SWIG_Py_Void();
50084 return resultobj;
50085 fail:
50086 return NULL;
50087 }
50088
50089
50090 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50091 PyObject *resultobj = 0;
50092 wxSizer *arg1 = (wxSizer *) 0 ;
50093 wxWindow *arg2 = (wxWindow *) 0 ;
50094 wxWindow *arg3 = (wxWindow *) 0 ;
50095 bool arg4 = (bool) false ;
50096 bool result;
50097 void *argp1 = 0 ;
50098 int res1 = 0 ;
50099 void *argp2 = 0 ;
50100 int res2 = 0 ;
50101 void *argp3 = 0 ;
50102 int res3 = 0 ;
50103 bool val4 ;
50104 int ecode4 = 0 ;
50105 PyObject * obj0 = 0 ;
50106 PyObject * obj1 = 0 ;
50107 PyObject * obj2 = 0 ;
50108 PyObject * obj3 = 0 ;
50109 char * kwnames[] = {
50110 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50111 };
50112
50113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50115 if (!SWIG_IsOK(res1)) {
50116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50117 }
50118 arg1 = reinterpret_cast< wxSizer * >(argp1);
50119 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50120 if (!SWIG_IsOK(res2)) {
50121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50122 }
50123 arg2 = reinterpret_cast< wxWindow * >(argp2);
50124 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50125 if (!SWIG_IsOK(res3)) {
50126 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50127 }
50128 arg3 = reinterpret_cast< wxWindow * >(argp3);
50129 if (obj3) {
50130 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50131 if (!SWIG_IsOK(ecode4)) {
50132 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50133 }
50134 arg4 = static_cast< bool >(val4);
50135 }
50136 {
50137 PyThreadState* __tstate = wxPyBeginAllowThreads();
50138 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50139 wxPyEndAllowThreads(__tstate);
50140 if (PyErr_Occurred()) SWIG_fail;
50141 }
50142 {
50143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50144 }
50145 return resultobj;
50146 fail:
50147 return NULL;
50148 }
50149
50150
50151 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50152 PyObject *resultobj = 0;
50153 wxSizer *arg1 = (wxSizer *) 0 ;
50154 wxSizer *arg2 = (wxSizer *) 0 ;
50155 wxSizer *arg3 = (wxSizer *) 0 ;
50156 bool arg4 = (bool) false ;
50157 bool result;
50158 void *argp1 = 0 ;
50159 int res1 = 0 ;
50160 void *argp2 = 0 ;
50161 int res2 = 0 ;
50162 void *argp3 = 0 ;
50163 int res3 = 0 ;
50164 bool val4 ;
50165 int ecode4 = 0 ;
50166 PyObject * obj0 = 0 ;
50167 PyObject * obj1 = 0 ;
50168 PyObject * obj2 = 0 ;
50169 PyObject * obj3 = 0 ;
50170 char * kwnames[] = {
50171 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50172 };
50173
50174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50176 if (!SWIG_IsOK(res1)) {
50177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50178 }
50179 arg1 = reinterpret_cast< wxSizer * >(argp1);
50180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50181 if (!SWIG_IsOK(res2)) {
50182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50183 }
50184 arg2 = reinterpret_cast< wxSizer * >(argp2);
50185 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50186 if (!SWIG_IsOK(res3)) {
50187 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50188 }
50189 arg3 = reinterpret_cast< wxSizer * >(argp3);
50190 if (obj3) {
50191 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50192 if (!SWIG_IsOK(ecode4)) {
50193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50194 }
50195 arg4 = static_cast< bool >(val4);
50196 }
50197 {
50198 PyThreadState* __tstate = wxPyBeginAllowThreads();
50199 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50200 wxPyEndAllowThreads(__tstate);
50201 if (PyErr_Occurred()) SWIG_fail;
50202 }
50203 {
50204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50205 }
50206 return resultobj;
50207 fail:
50208 return NULL;
50209 }
50210
50211
50212 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50213 PyObject *resultobj = 0;
50214 wxSizer *arg1 = (wxSizer *) 0 ;
50215 size_t arg2 ;
50216 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50217 bool result;
50218 void *argp1 = 0 ;
50219 int res1 = 0 ;
50220 size_t val2 ;
50221 int ecode2 = 0 ;
50222 void *argp3 = 0 ;
50223 int res3 = 0 ;
50224 PyObject * obj0 = 0 ;
50225 PyObject * obj1 = 0 ;
50226 PyObject * obj2 = 0 ;
50227 char * kwnames[] = {
50228 (char *) "self",(char *) "index",(char *) "newitem", NULL
50229 };
50230
50231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50233 if (!SWIG_IsOK(res1)) {
50234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50235 }
50236 arg1 = reinterpret_cast< wxSizer * >(argp1);
50237 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50238 if (!SWIG_IsOK(ecode2)) {
50239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50240 }
50241 arg2 = static_cast< size_t >(val2);
50242 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50243 if (!SWIG_IsOK(res3)) {
50244 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50245 }
50246 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50247 {
50248 PyThreadState* __tstate = wxPyBeginAllowThreads();
50249 result = (bool)(arg1)->Replace(arg2,arg3);
50250 wxPyEndAllowThreads(__tstate);
50251 if (PyErr_Occurred()) SWIG_fail;
50252 }
50253 {
50254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50255 }
50256 return resultobj;
50257 fail:
50258 return NULL;
50259 }
50260
50261
50262 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50263 PyObject *resultobj = 0;
50264 wxSizer *arg1 = (wxSizer *) 0 ;
50265 wxWindow *arg2 = (wxWindow *) 0 ;
50266 void *argp1 = 0 ;
50267 int res1 = 0 ;
50268 void *argp2 = 0 ;
50269 int res2 = 0 ;
50270 PyObject * obj0 = 0 ;
50271 PyObject * obj1 = 0 ;
50272 char * kwnames[] = {
50273 (char *) "self",(char *) "window", NULL
50274 };
50275
50276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50278 if (!SWIG_IsOK(res1)) {
50279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50280 }
50281 arg1 = reinterpret_cast< wxSizer * >(argp1);
50282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50283 if (!SWIG_IsOK(res2)) {
50284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50285 }
50286 arg2 = reinterpret_cast< wxWindow * >(argp2);
50287 {
50288 PyThreadState* __tstate = wxPyBeginAllowThreads();
50289 (arg1)->SetContainingWindow(arg2);
50290 wxPyEndAllowThreads(__tstate);
50291 if (PyErr_Occurred()) SWIG_fail;
50292 }
50293 resultobj = SWIG_Py_Void();
50294 return resultobj;
50295 fail:
50296 return NULL;
50297 }
50298
50299
50300 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50301 PyObject *resultobj = 0;
50302 wxSizer *arg1 = (wxSizer *) 0 ;
50303 wxWindow *result = 0 ;
50304 void *argp1 = 0 ;
50305 int res1 = 0 ;
50306 PyObject *swig_obj[1] ;
50307
50308 if (!args) SWIG_fail;
50309 swig_obj[0] = args;
50310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50311 if (!SWIG_IsOK(res1)) {
50312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50313 }
50314 arg1 = reinterpret_cast< wxSizer * >(argp1);
50315 {
50316 PyThreadState* __tstate = wxPyBeginAllowThreads();
50317 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50318 wxPyEndAllowThreads(__tstate);
50319 if (PyErr_Occurred()) SWIG_fail;
50320 }
50321 {
50322 resultobj = wxPyMake_wxObject(result, 0);
50323 }
50324 return resultobj;
50325 fail:
50326 return NULL;
50327 }
50328
50329
50330 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50331 PyObject *resultobj = 0;
50332 wxSizer *arg1 = (wxSizer *) 0 ;
50333 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50334 wxSizerItem *result = 0 ;
50335 void *argp1 = 0 ;
50336 int res1 = 0 ;
50337 int res2 = 0 ;
50338 PyObject * obj0 = 0 ;
50339 PyObject * obj1 = 0 ;
50340 char * kwnames[] = {
50341 (char *) "self",(char *) "item", NULL
50342 };
50343
50344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50346 if (!SWIG_IsOK(res1)) {
50347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50348 }
50349 arg1 = reinterpret_cast< wxSizer * >(argp1);
50350 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50351 if (!SWIG_IsOK(res2)) {
50352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50353 }
50354 {
50355 PyThreadState* __tstate = wxPyBeginAllowThreads();
50356 result = (wxSizerItem *)(arg1)->Add(arg2);
50357 wxPyEndAllowThreads(__tstate);
50358 if (PyErr_Occurred()) SWIG_fail;
50359 }
50360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50361 return resultobj;
50362 fail:
50363 return NULL;
50364 }
50365
50366
50367 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50368 PyObject *resultobj = 0;
50369 wxSizer *arg1 = (wxSizer *) 0 ;
50370 size_t arg2 ;
50371 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50372 wxSizerItem *result = 0 ;
50373 void *argp1 = 0 ;
50374 int res1 = 0 ;
50375 size_t val2 ;
50376 int ecode2 = 0 ;
50377 int res3 = 0 ;
50378 PyObject * obj0 = 0 ;
50379 PyObject * obj1 = 0 ;
50380 PyObject * obj2 = 0 ;
50381 char * kwnames[] = {
50382 (char *) "self",(char *) "index",(char *) "item", NULL
50383 };
50384
50385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50387 if (!SWIG_IsOK(res1)) {
50388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50389 }
50390 arg1 = reinterpret_cast< wxSizer * >(argp1);
50391 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50392 if (!SWIG_IsOK(ecode2)) {
50393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50394 }
50395 arg2 = static_cast< size_t >(val2);
50396 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50397 if (!SWIG_IsOK(res3)) {
50398 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50399 }
50400 {
50401 PyThreadState* __tstate = wxPyBeginAllowThreads();
50402 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50403 wxPyEndAllowThreads(__tstate);
50404 if (PyErr_Occurred()) SWIG_fail;
50405 }
50406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50407 return resultobj;
50408 fail:
50409 return NULL;
50410 }
50411
50412
50413 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50414 PyObject *resultobj = 0;
50415 wxSizer *arg1 = (wxSizer *) 0 ;
50416 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50417 wxSizerItem *result = 0 ;
50418 void *argp1 = 0 ;
50419 int res1 = 0 ;
50420 int res2 = 0 ;
50421 PyObject * obj0 = 0 ;
50422 PyObject * obj1 = 0 ;
50423 char * kwnames[] = {
50424 (char *) "self",(char *) "item", NULL
50425 };
50426
50427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50429 if (!SWIG_IsOK(res1)) {
50430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50431 }
50432 arg1 = reinterpret_cast< wxSizer * >(argp1);
50433 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50434 if (!SWIG_IsOK(res2)) {
50435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50436 }
50437 {
50438 PyThreadState* __tstate = wxPyBeginAllowThreads();
50439 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50440 wxPyEndAllowThreads(__tstate);
50441 if (PyErr_Occurred()) SWIG_fail;
50442 }
50443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50444 return resultobj;
50445 fail:
50446 return NULL;
50447 }
50448
50449
50450 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50451 PyObject *resultobj = 0;
50452 wxSizer *arg1 = (wxSizer *) 0 ;
50453 int arg2 ;
50454 int arg3 ;
50455 int arg4 ;
50456 int arg5 ;
50457 void *argp1 = 0 ;
50458 int res1 = 0 ;
50459 int val2 ;
50460 int ecode2 = 0 ;
50461 int val3 ;
50462 int ecode3 = 0 ;
50463 int val4 ;
50464 int ecode4 = 0 ;
50465 int val5 ;
50466 int ecode5 = 0 ;
50467 PyObject * obj0 = 0 ;
50468 PyObject * obj1 = 0 ;
50469 PyObject * obj2 = 0 ;
50470 PyObject * obj3 = 0 ;
50471 PyObject * obj4 = 0 ;
50472 char * kwnames[] = {
50473 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50474 };
50475
50476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50478 if (!SWIG_IsOK(res1)) {
50479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50480 }
50481 arg1 = reinterpret_cast< wxSizer * >(argp1);
50482 ecode2 = SWIG_AsVal_int(obj1, &val2);
50483 if (!SWIG_IsOK(ecode2)) {
50484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50485 }
50486 arg2 = static_cast< int >(val2);
50487 ecode3 = SWIG_AsVal_int(obj2, &val3);
50488 if (!SWIG_IsOK(ecode3)) {
50489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50490 }
50491 arg3 = static_cast< int >(val3);
50492 ecode4 = SWIG_AsVal_int(obj3, &val4);
50493 if (!SWIG_IsOK(ecode4)) {
50494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50495 }
50496 arg4 = static_cast< int >(val4);
50497 ecode5 = SWIG_AsVal_int(obj4, &val5);
50498 if (!SWIG_IsOK(ecode5)) {
50499 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50500 }
50501 arg5 = static_cast< int >(val5);
50502 {
50503 PyThreadState* __tstate = wxPyBeginAllowThreads();
50504 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50505 wxPyEndAllowThreads(__tstate);
50506 if (PyErr_Occurred()) SWIG_fail;
50507 }
50508 resultobj = SWIG_Py_Void();
50509 return resultobj;
50510 fail:
50511 return NULL;
50512 }
50513
50514
50515 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50516 PyObject *resultobj = 0;
50517 wxSizer *arg1 = (wxSizer *) 0 ;
50518 wxSize *arg2 = 0 ;
50519 void *argp1 = 0 ;
50520 int res1 = 0 ;
50521 wxSize temp2 ;
50522 PyObject * obj0 = 0 ;
50523 PyObject * obj1 = 0 ;
50524 char * kwnames[] = {
50525 (char *) "self",(char *) "size", NULL
50526 };
50527
50528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50530 if (!SWIG_IsOK(res1)) {
50531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50532 }
50533 arg1 = reinterpret_cast< wxSizer * >(argp1);
50534 {
50535 arg2 = &temp2;
50536 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50537 }
50538 {
50539 PyThreadState* __tstate = wxPyBeginAllowThreads();
50540 (arg1)->SetMinSize((wxSize const &)*arg2);
50541 wxPyEndAllowThreads(__tstate);
50542 if (PyErr_Occurred()) SWIG_fail;
50543 }
50544 resultobj = SWIG_Py_Void();
50545 return resultobj;
50546 fail:
50547 return NULL;
50548 }
50549
50550
50551 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50552 PyObject *resultobj = 0;
50553 wxSizer *arg1 = (wxSizer *) 0 ;
50554 wxSize result;
50555 void *argp1 = 0 ;
50556 int res1 = 0 ;
50557 PyObject *swig_obj[1] ;
50558
50559 if (!args) SWIG_fail;
50560 swig_obj[0] = args;
50561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50562 if (!SWIG_IsOK(res1)) {
50563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50564 }
50565 arg1 = reinterpret_cast< wxSizer * >(argp1);
50566 {
50567 PyThreadState* __tstate = wxPyBeginAllowThreads();
50568 result = (arg1)->GetSize();
50569 wxPyEndAllowThreads(__tstate);
50570 if (PyErr_Occurred()) SWIG_fail;
50571 }
50572 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50573 return resultobj;
50574 fail:
50575 return NULL;
50576 }
50577
50578
50579 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50580 PyObject *resultobj = 0;
50581 wxSizer *arg1 = (wxSizer *) 0 ;
50582 wxPoint result;
50583 void *argp1 = 0 ;
50584 int res1 = 0 ;
50585 PyObject *swig_obj[1] ;
50586
50587 if (!args) SWIG_fail;
50588 swig_obj[0] = args;
50589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50590 if (!SWIG_IsOK(res1)) {
50591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50592 }
50593 arg1 = reinterpret_cast< wxSizer * >(argp1);
50594 {
50595 PyThreadState* __tstate = wxPyBeginAllowThreads();
50596 result = (arg1)->GetPosition();
50597 wxPyEndAllowThreads(__tstate);
50598 if (PyErr_Occurred()) SWIG_fail;
50599 }
50600 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50601 return resultobj;
50602 fail:
50603 return NULL;
50604 }
50605
50606
50607 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50608 PyObject *resultobj = 0;
50609 wxSizer *arg1 = (wxSizer *) 0 ;
50610 wxSize result;
50611 void *argp1 = 0 ;
50612 int res1 = 0 ;
50613 PyObject *swig_obj[1] ;
50614
50615 if (!args) SWIG_fail;
50616 swig_obj[0] = args;
50617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50618 if (!SWIG_IsOK(res1)) {
50619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50620 }
50621 arg1 = reinterpret_cast< wxSizer * >(argp1);
50622 {
50623 PyThreadState* __tstate = wxPyBeginAllowThreads();
50624 result = (arg1)->GetMinSize();
50625 wxPyEndAllowThreads(__tstate);
50626 if (PyErr_Occurred()) SWIG_fail;
50627 }
50628 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50629 return resultobj;
50630 fail:
50631 return NULL;
50632 }
50633
50634
50635 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50636 PyObject *resultobj = 0;
50637 wxSizer *arg1 = (wxSizer *) 0 ;
50638 void *argp1 = 0 ;
50639 int res1 = 0 ;
50640 PyObject *swig_obj[1] ;
50641
50642 if (!args) SWIG_fail;
50643 swig_obj[0] = args;
50644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50645 if (!SWIG_IsOK(res1)) {
50646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50647 }
50648 arg1 = reinterpret_cast< wxSizer * >(argp1);
50649 {
50650 PyThreadState* __tstate = wxPyBeginAllowThreads();
50651 (arg1)->RecalcSizes();
50652 wxPyEndAllowThreads(__tstate);
50653 if (PyErr_Occurred()) SWIG_fail;
50654 }
50655 resultobj = SWIG_Py_Void();
50656 return resultobj;
50657 fail:
50658 return NULL;
50659 }
50660
50661
50662 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50663 PyObject *resultobj = 0;
50664 wxSizer *arg1 = (wxSizer *) 0 ;
50665 wxSize result;
50666 void *argp1 = 0 ;
50667 int res1 = 0 ;
50668 PyObject *swig_obj[1] ;
50669
50670 if (!args) SWIG_fail;
50671 swig_obj[0] = args;
50672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50673 if (!SWIG_IsOK(res1)) {
50674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50675 }
50676 arg1 = reinterpret_cast< wxSizer * >(argp1);
50677 {
50678 PyThreadState* __tstate = wxPyBeginAllowThreads();
50679 result = (arg1)->CalcMin();
50680 wxPyEndAllowThreads(__tstate);
50681 if (PyErr_Occurred()) SWIG_fail;
50682 }
50683 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50684 return resultobj;
50685 fail:
50686 return NULL;
50687 }
50688
50689
50690 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50691 PyObject *resultobj = 0;
50692 wxSizer *arg1 = (wxSizer *) 0 ;
50693 void *argp1 = 0 ;
50694 int res1 = 0 ;
50695 PyObject *swig_obj[1] ;
50696
50697 if (!args) SWIG_fail;
50698 swig_obj[0] = args;
50699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50700 if (!SWIG_IsOK(res1)) {
50701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50702 }
50703 arg1 = reinterpret_cast< wxSizer * >(argp1);
50704 {
50705 PyThreadState* __tstate = wxPyBeginAllowThreads();
50706 (arg1)->Layout();
50707 wxPyEndAllowThreads(__tstate);
50708 if (PyErr_Occurred()) SWIG_fail;
50709 }
50710 resultobj = SWIG_Py_Void();
50711 return resultobj;
50712 fail:
50713 return NULL;
50714 }
50715
50716
50717 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50718 PyObject *resultobj = 0;
50719 wxSizer *arg1 = (wxSizer *) 0 ;
50720 wxWindow *arg2 = (wxWindow *) 0 ;
50721 wxSize result;
50722 void *argp1 = 0 ;
50723 int res1 = 0 ;
50724 void *argp2 = 0 ;
50725 int res2 = 0 ;
50726 PyObject * obj0 = 0 ;
50727 PyObject * obj1 = 0 ;
50728 char * kwnames[] = {
50729 (char *) "self",(char *) "window", NULL
50730 };
50731
50732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50734 if (!SWIG_IsOK(res1)) {
50735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50736 }
50737 arg1 = reinterpret_cast< wxSizer * >(argp1);
50738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50739 if (!SWIG_IsOK(res2)) {
50740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50741 }
50742 arg2 = reinterpret_cast< wxWindow * >(argp2);
50743 {
50744 PyThreadState* __tstate = wxPyBeginAllowThreads();
50745 result = (arg1)->Fit(arg2);
50746 wxPyEndAllowThreads(__tstate);
50747 if (PyErr_Occurred()) SWIG_fail;
50748 }
50749 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50750 return resultobj;
50751 fail:
50752 return NULL;
50753 }
50754
50755
50756 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50757 PyObject *resultobj = 0;
50758 wxSizer *arg1 = (wxSizer *) 0 ;
50759 wxWindow *arg2 = (wxWindow *) 0 ;
50760 void *argp1 = 0 ;
50761 int res1 = 0 ;
50762 void *argp2 = 0 ;
50763 int res2 = 0 ;
50764 PyObject * obj0 = 0 ;
50765 PyObject * obj1 = 0 ;
50766 char * kwnames[] = {
50767 (char *) "self",(char *) "window", NULL
50768 };
50769
50770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50772 if (!SWIG_IsOK(res1)) {
50773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50774 }
50775 arg1 = reinterpret_cast< wxSizer * >(argp1);
50776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50777 if (!SWIG_IsOK(res2)) {
50778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50779 }
50780 arg2 = reinterpret_cast< wxWindow * >(argp2);
50781 {
50782 PyThreadState* __tstate = wxPyBeginAllowThreads();
50783 (arg1)->FitInside(arg2);
50784 wxPyEndAllowThreads(__tstate);
50785 if (PyErr_Occurred()) SWIG_fail;
50786 }
50787 resultobj = SWIG_Py_Void();
50788 return resultobj;
50789 fail:
50790 return NULL;
50791 }
50792
50793
50794 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50795 PyObject *resultobj = 0;
50796 wxSizer *arg1 = (wxSizer *) 0 ;
50797 wxWindow *arg2 = (wxWindow *) 0 ;
50798 void *argp1 = 0 ;
50799 int res1 = 0 ;
50800 void *argp2 = 0 ;
50801 int res2 = 0 ;
50802 PyObject * obj0 = 0 ;
50803 PyObject * obj1 = 0 ;
50804 char * kwnames[] = {
50805 (char *) "self",(char *) "window", NULL
50806 };
50807
50808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50810 if (!SWIG_IsOK(res1)) {
50811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50812 }
50813 arg1 = reinterpret_cast< wxSizer * >(argp1);
50814 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50815 if (!SWIG_IsOK(res2)) {
50816 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50817 }
50818 arg2 = reinterpret_cast< wxWindow * >(argp2);
50819 {
50820 PyThreadState* __tstate = wxPyBeginAllowThreads();
50821 (arg1)->SetSizeHints(arg2);
50822 wxPyEndAllowThreads(__tstate);
50823 if (PyErr_Occurred()) SWIG_fail;
50824 }
50825 resultobj = SWIG_Py_Void();
50826 return resultobj;
50827 fail:
50828 return NULL;
50829 }
50830
50831
50832 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50833 PyObject *resultobj = 0;
50834 wxSizer *arg1 = (wxSizer *) 0 ;
50835 wxWindow *arg2 = (wxWindow *) 0 ;
50836 void *argp1 = 0 ;
50837 int res1 = 0 ;
50838 void *argp2 = 0 ;
50839 int res2 = 0 ;
50840 PyObject * obj0 = 0 ;
50841 PyObject * obj1 = 0 ;
50842 char * kwnames[] = {
50843 (char *) "self",(char *) "window", NULL
50844 };
50845
50846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50848 if (!SWIG_IsOK(res1)) {
50849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50850 }
50851 arg1 = reinterpret_cast< wxSizer * >(argp1);
50852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50853 if (!SWIG_IsOK(res2)) {
50854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50855 }
50856 arg2 = reinterpret_cast< wxWindow * >(argp2);
50857 {
50858 PyThreadState* __tstate = wxPyBeginAllowThreads();
50859 (arg1)->SetVirtualSizeHints(arg2);
50860 wxPyEndAllowThreads(__tstate);
50861 if (PyErr_Occurred()) SWIG_fail;
50862 }
50863 resultobj = SWIG_Py_Void();
50864 return resultobj;
50865 fail:
50866 return NULL;
50867 }
50868
50869
50870 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50871 PyObject *resultobj = 0;
50872 wxSizer *arg1 = (wxSizer *) 0 ;
50873 bool arg2 = (bool) false ;
50874 void *argp1 = 0 ;
50875 int res1 = 0 ;
50876 bool val2 ;
50877 int ecode2 = 0 ;
50878 PyObject * obj0 = 0 ;
50879 PyObject * obj1 = 0 ;
50880 char * kwnames[] = {
50881 (char *) "self",(char *) "deleteWindows", NULL
50882 };
50883
50884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50886 if (!SWIG_IsOK(res1)) {
50887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50888 }
50889 arg1 = reinterpret_cast< wxSizer * >(argp1);
50890 if (obj1) {
50891 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50892 if (!SWIG_IsOK(ecode2)) {
50893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50894 }
50895 arg2 = static_cast< bool >(val2);
50896 }
50897 {
50898 PyThreadState* __tstate = wxPyBeginAllowThreads();
50899 (arg1)->Clear(arg2);
50900 wxPyEndAllowThreads(__tstate);
50901 if (PyErr_Occurred()) SWIG_fail;
50902 }
50903 resultobj = SWIG_Py_Void();
50904 return resultobj;
50905 fail:
50906 return NULL;
50907 }
50908
50909
50910 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50911 PyObject *resultobj = 0;
50912 wxSizer *arg1 = (wxSizer *) 0 ;
50913 void *argp1 = 0 ;
50914 int res1 = 0 ;
50915 PyObject *swig_obj[1] ;
50916
50917 if (!args) SWIG_fail;
50918 swig_obj[0] = args;
50919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50920 if (!SWIG_IsOK(res1)) {
50921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50922 }
50923 arg1 = reinterpret_cast< wxSizer * >(argp1);
50924 {
50925 PyThreadState* __tstate = wxPyBeginAllowThreads();
50926 (arg1)->DeleteWindows();
50927 wxPyEndAllowThreads(__tstate);
50928 if (PyErr_Occurred()) SWIG_fail;
50929 }
50930 resultobj = SWIG_Py_Void();
50931 return resultobj;
50932 fail:
50933 return NULL;
50934 }
50935
50936
50937 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50938 PyObject *resultobj = 0;
50939 wxSizer *arg1 = (wxSizer *) 0 ;
50940 PyObject *result = 0 ;
50941 void *argp1 = 0 ;
50942 int res1 = 0 ;
50943 PyObject *swig_obj[1] ;
50944
50945 if (!args) SWIG_fail;
50946 swig_obj[0] = args;
50947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50948 if (!SWIG_IsOK(res1)) {
50949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50950 }
50951 arg1 = reinterpret_cast< wxSizer * >(argp1);
50952 {
50953 PyThreadState* __tstate = wxPyBeginAllowThreads();
50954 result = (PyObject *)wxSizer_GetChildren(arg1);
50955 wxPyEndAllowThreads(__tstate);
50956 if (PyErr_Occurred()) SWIG_fail;
50957 }
50958 resultobj = result;
50959 return resultobj;
50960 fail:
50961 return NULL;
50962 }
50963
50964
50965 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50966 PyObject *resultobj = 0;
50967 wxSizer *arg1 = (wxSizer *) 0 ;
50968 PyObject *arg2 = (PyObject *) 0 ;
50969 bool arg3 = (bool) true ;
50970 bool arg4 = (bool) false ;
50971 bool result;
50972 void *argp1 = 0 ;
50973 int res1 = 0 ;
50974 bool val3 ;
50975 int ecode3 = 0 ;
50976 bool val4 ;
50977 int ecode4 = 0 ;
50978 PyObject * obj0 = 0 ;
50979 PyObject * obj1 = 0 ;
50980 PyObject * obj2 = 0 ;
50981 PyObject * obj3 = 0 ;
50982 char * kwnames[] = {
50983 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
50984 };
50985
50986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50988 if (!SWIG_IsOK(res1)) {
50989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
50990 }
50991 arg1 = reinterpret_cast< wxSizer * >(argp1);
50992 arg2 = obj1;
50993 if (obj2) {
50994 ecode3 = SWIG_AsVal_bool(obj2, &val3);
50995 if (!SWIG_IsOK(ecode3)) {
50996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
50997 }
50998 arg3 = static_cast< bool >(val3);
50999 }
51000 if (obj3) {
51001 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51002 if (!SWIG_IsOK(ecode4)) {
51003 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51004 }
51005 arg4 = static_cast< bool >(val4);
51006 }
51007 {
51008 PyThreadState* __tstate = wxPyBeginAllowThreads();
51009 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51010 wxPyEndAllowThreads(__tstate);
51011 if (PyErr_Occurred()) SWIG_fail;
51012 }
51013 {
51014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51015 }
51016 return resultobj;
51017 fail:
51018 return NULL;
51019 }
51020
51021
51022 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51023 PyObject *resultobj = 0;
51024 wxSizer *arg1 = (wxSizer *) 0 ;
51025 PyObject *arg2 = (PyObject *) 0 ;
51026 bool result;
51027 void *argp1 = 0 ;
51028 int res1 = 0 ;
51029 PyObject * obj0 = 0 ;
51030 PyObject * obj1 = 0 ;
51031 char * kwnames[] = {
51032 (char *) "self",(char *) "item", NULL
51033 };
51034
51035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51037 if (!SWIG_IsOK(res1)) {
51038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51039 }
51040 arg1 = reinterpret_cast< wxSizer * >(argp1);
51041 arg2 = obj1;
51042 {
51043 PyThreadState* __tstate = wxPyBeginAllowThreads();
51044 result = (bool)wxSizer_IsShown(arg1,arg2);
51045 wxPyEndAllowThreads(__tstate);
51046 if (PyErr_Occurred()) SWIG_fail;
51047 }
51048 {
51049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51050 }
51051 return resultobj;
51052 fail:
51053 return NULL;
51054 }
51055
51056
51057 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51058 PyObject *resultobj = 0;
51059 wxSizer *arg1 = (wxSizer *) 0 ;
51060 bool arg2 ;
51061 void *argp1 = 0 ;
51062 int res1 = 0 ;
51063 bool val2 ;
51064 int ecode2 = 0 ;
51065 PyObject * obj0 = 0 ;
51066 PyObject * obj1 = 0 ;
51067 char * kwnames[] = {
51068 (char *) "self",(char *) "show", NULL
51069 };
51070
51071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51073 if (!SWIG_IsOK(res1)) {
51074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51075 }
51076 arg1 = reinterpret_cast< wxSizer * >(argp1);
51077 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51078 if (!SWIG_IsOK(ecode2)) {
51079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51080 }
51081 arg2 = static_cast< bool >(val2);
51082 {
51083 PyThreadState* __tstate = wxPyBeginAllowThreads();
51084 (arg1)->ShowItems(arg2);
51085 wxPyEndAllowThreads(__tstate);
51086 if (PyErr_Occurred()) SWIG_fail;
51087 }
51088 resultobj = SWIG_Py_Void();
51089 return resultobj;
51090 fail:
51091 return NULL;
51092 }
51093
51094
51095 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51096 PyObject *obj;
51097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51098 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51099 return SWIG_Py_Void();
51100 }
51101
51102 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51103 PyObject *resultobj = 0;
51104 wxPySizer *result = 0 ;
51105
51106 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51107 {
51108 PyThreadState* __tstate = wxPyBeginAllowThreads();
51109 result = (wxPySizer *)new wxPySizer();
51110 wxPyEndAllowThreads(__tstate);
51111 if (PyErr_Occurred()) SWIG_fail;
51112 }
51113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51114 return resultobj;
51115 fail:
51116 return NULL;
51117 }
51118
51119
51120 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51121 PyObject *resultobj = 0;
51122 wxPySizer *arg1 = (wxPySizer *) 0 ;
51123 PyObject *arg2 = (PyObject *) 0 ;
51124 PyObject *arg3 = (PyObject *) 0 ;
51125 void *argp1 = 0 ;
51126 int res1 = 0 ;
51127 PyObject * obj0 = 0 ;
51128 PyObject * obj1 = 0 ;
51129 PyObject * obj2 = 0 ;
51130 char * kwnames[] = {
51131 (char *) "self",(char *) "self",(char *) "_class", NULL
51132 };
51133
51134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51136 if (!SWIG_IsOK(res1)) {
51137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51138 }
51139 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51140 arg2 = obj1;
51141 arg3 = obj2;
51142 {
51143 PyThreadState* __tstate = wxPyBeginAllowThreads();
51144 (arg1)->_setCallbackInfo(arg2,arg3);
51145 wxPyEndAllowThreads(__tstate);
51146 if (PyErr_Occurred()) SWIG_fail;
51147 }
51148 resultobj = SWIG_Py_Void();
51149 return resultobj;
51150 fail:
51151 return NULL;
51152 }
51153
51154
51155 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51156 PyObject *obj;
51157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51158 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51159 return SWIG_Py_Void();
51160 }
51161
51162 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51163 return SWIG_Python_InitShadowInstance(args);
51164 }
51165
51166 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51167 PyObject *resultobj = 0;
51168 int arg1 = (int) wxHORIZONTAL ;
51169 wxBoxSizer *result = 0 ;
51170 int val1 ;
51171 int ecode1 = 0 ;
51172 PyObject * obj0 = 0 ;
51173 char * kwnames[] = {
51174 (char *) "orient", NULL
51175 };
51176
51177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51178 if (obj0) {
51179 ecode1 = SWIG_AsVal_int(obj0, &val1);
51180 if (!SWIG_IsOK(ecode1)) {
51181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51182 }
51183 arg1 = static_cast< int >(val1);
51184 }
51185 {
51186 PyThreadState* __tstate = wxPyBeginAllowThreads();
51187 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51188 wxPyEndAllowThreads(__tstate);
51189 if (PyErr_Occurred()) SWIG_fail;
51190 }
51191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51192 return resultobj;
51193 fail:
51194 return NULL;
51195 }
51196
51197
51198 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51199 PyObject *resultobj = 0;
51200 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51201 int result;
51202 void *argp1 = 0 ;
51203 int res1 = 0 ;
51204 PyObject *swig_obj[1] ;
51205
51206 if (!args) SWIG_fail;
51207 swig_obj[0] = args;
51208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51209 if (!SWIG_IsOK(res1)) {
51210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51211 }
51212 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51213 {
51214 PyThreadState* __tstate = wxPyBeginAllowThreads();
51215 result = (int)(arg1)->GetOrientation();
51216 wxPyEndAllowThreads(__tstate);
51217 if (PyErr_Occurred()) SWIG_fail;
51218 }
51219 resultobj = SWIG_From_int(static_cast< int >(result));
51220 return resultobj;
51221 fail:
51222 return NULL;
51223 }
51224
51225
51226 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51227 PyObject *resultobj = 0;
51228 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51229 int arg2 ;
51230 void *argp1 = 0 ;
51231 int res1 = 0 ;
51232 int val2 ;
51233 int ecode2 = 0 ;
51234 PyObject * obj0 = 0 ;
51235 PyObject * obj1 = 0 ;
51236 char * kwnames[] = {
51237 (char *) "self",(char *) "orient", NULL
51238 };
51239
51240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51242 if (!SWIG_IsOK(res1)) {
51243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51244 }
51245 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51246 ecode2 = SWIG_AsVal_int(obj1, &val2);
51247 if (!SWIG_IsOK(ecode2)) {
51248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51249 }
51250 arg2 = static_cast< int >(val2);
51251 {
51252 PyThreadState* __tstate = wxPyBeginAllowThreads();
51253 (arg1)->SetOrientation(arg2);
51254 wxPyEndAllowThreads(__tstate);
51255 if (PyErr_Occurred()) SWIG_fail;
51256 }
51257 resultobj = SWIG_Py_Void();
51258 return resultobj;
51259 fail:
51260 return NULL;
51261 }
51262
51263
51264 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51265 PyObject *obj;
51266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51267 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51268 return SWIG_Py_Void();
51269 }
51270
51271 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51272 return SWIG_Python_InitShadowInstance(args);
51273 }
51274
51275 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51276 PyObject *resultobj = 0;
51277 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51278 int arg2 = (int) wxHORIZONTAL ;
51279 wxStaticBoxSizer *result = 0 ;
51280 void *argp1 = 0 ;
51281 int res1 = 0 ;
51282 int val2 ;
51283 int ecode2 = 0 ;
51284 PyObject * obj0 = 0 ;
51285 PyObject * obj1 = 0 ;
51286 char * kwnames[] = {
51287 (char *) "box",(char *) "orient", NULL
51288 };
51289
51290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51292 if (!SWIG_IsOK(res1)) {
51293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51294 }
51295 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51296 if (obj1) {
51297 ecode2 = SWIG_AsVal_int(obj1, &val2);
51298 if (!SWIG_IsOK(ecode2)) {
51299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51300 }
51301 arg2 = static_cast< int >(val2);
51302 }
51303 {
51304 PyThreadState* __tstate = wxPyBeginAllowThreads();
51305 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51306 wxPyEndAllowThreads(__tstate);
51307 if (PyErr_Occurred()) SWIG_fail;
51308 }
51309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51310 return resultobj;
51311 fail:
51312 return NULL;
51313 }
51314
51315
51316 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51317 PyObject *resultobj = 0;
51318 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51319 wxStaticBox *result = 0 ;
51320 void *argp1 = 0 ;
51321 int res1 = 0 ;
51322 PyObject *swig_obj[1] ;
51323
51324 if (!args) SWIG_fail;
51325 swig_obj[0] = args;
51326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51327 if (!SWIG_IsOK(res1)) {
51328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51329 }
51330 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51331 {
51332 PyThreadState* __tstate = wxPyBeginAllowThreads();
51333 result = (wxStaticBox *)(arg1)->GetStaticBox();
51334 wxPyEndAllowThreads(__tstate);
51335 if (PyErr_Occurred()) SWIG_fail;
51336 }
51337 {
51338 resultobj = wxPyMake_wxObject(result, (bool)0);
51339 }
51340 return resultobj;
51341 fail:
51342 return NULL;
51343 }
51344
51345
51346 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51347 PyObject *obj;
51348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51349 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51350 return SWIG_Py_Void();
51351 }
51352
51353 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51354 return SWIG_Python_InitShadowInstance(args);
51355 }
51356
51357 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51358 PyObject *resultobj = 0;
51359 int arg1 = (int) 1 ;
51360 int arg2 = (int) 0 ;
51361 int arg3 = (int) 0 ;
51362 int arg4 = (int) 0 ;
51363 wxGridSizer *result = 0 ;
51364 int val1 ;
51365 int ecode1 = 0 ;
51366 int val2 ;
51367 int ecode2 = 0 ;
51368 int val3 ;
51369 int ecode3 = 0 ;
51370 int val4 ;
51371 int ecode4 = 0 ;
51372 PyObject * obj0 = 0 ;
51373 PyObject * obj1 = 0 ;
51374 PyObject * obj2 = 0 ;
51375 PyObject * obj3 = 0 ;
51376 char * kwnames[] = {
51377 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51378 };
51379
51380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51381 if (obj0) {
51382 ecode1 = SWIG_AsVal_int(obj0, &val1);
51383 if (!SWIG_IsOK(ecode1)) {
51384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51385 }
51386 arg1 = static_cast< int >(val1);
51387 }
51388 if (obj1) {
51389 ecode2 = SWIG_AsVal_int(obj1, &val2);
51390 if (!SWIG_IsOK(ecode2)) {
51391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51392 }
51393 arg2 = static_cast< int >(val2);
51394 }
51395 if (obj2) {
51396 ecode3 = SWIG_AsVal_int(obj2, &val3);
51397 if (!SWIG_IsOK(ecode3)) {
51398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51399 }
51400 arg3 = static_cast< int >(val3);
51401 }
51402 if (obj3) {
51403 ecode4 = SWIG_AsVal_int(obj3, &val4);
51404 if (!SWIG_IsOK(ecode4)) {
51405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51406 }
51407 arg4 = static_cast< int >(val4);
51408 }
51409 {
51410 PyThreadState* __tstate = wxPyBeginAllowThreads();
51411 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51412 wxPyEndAllowThreads(__tstate);
51413 if (PyErr_Occurred()) SWIG_fail;
51414 }
51415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51416 return resultobj;
51417 fail:
51418 return NULL;
51419 }
51420
51421
51422 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51423 PyObject *resultobj = 0;
51424 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51425 int arg2 ;
51426 void *argp1 = 0 ;
51427 int res1 = 0 ;
51428 int val2 ;
51429 int ecode2 = 0 ;
51430 PyObject * obj0 = 0 ;
51431 PyObject * obj1 = 0 ;
51432 char * kwnames[] = {
51433 (char *) "self",(char *) "cols", NULL
51434 };
51435
51436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51438 if (!SWIG_IsOK(res1)) {
51439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51440 }
51441 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51442 ecode2 = SWIG_AsVal_int(obj1, &val2);
51443 if (!SWIG_IsOK(ecode2)) {
51444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51445 }
51446 arg2 = static_cast< int >(val2);
51447 {
51448 PyThreadState* __tstate = wxPyBeginAllowThreads();
51449 (arg1)->SetCols(arg2);
51450 wxPyEndAllowThreads(__tstate);
51451 if (PyErr_Occurred()) SWIG_fail;
51452 }
51453 resultobj = SWIG_Py_Void();
51454 return resultobj;
51455 fail:
51456 return NULL;
51457 }
51458
51459
51460 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51461 PyObject *resultobj = 0;
51462 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51463 int arg2 ;
51464 void *argp1 = 0 ;
51465 int res1 = 0 ;
51466 int val2 ;
51467 int ecode2 = 0 ;
51468 PyObject * obj0 = 0 ;
51469 PyObject * obj1 = 0 ;
51470 char * kwnames[] = {
51471 (char *) "self",(char *) "rows", NULL
51472 };
51473
51474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51476 if (!SWIG_IsOK(res1)) {
51477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51478 }
51479 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51480 ecode2 = SWIG_AsVal_int(obj1, &val2);
51481 if (!SWIG_IsOK(ecode2)) {
51482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51483 }
51484 arg2 = static_cast< int >(val2);
51485 {
51486 PyThreadState* __tstate = wxPyBeginAllowThreads();
51487 (arg1)->SetRows(arg2);
51488 wxPyEndAllowThreads(__tstate);
51489 if (PyErr_Occurred()) SWIG_fail;
51490 }
51491 resultobj = SWIG_Py_Void();
51492 return resultobj;
51493 fail:
51494 return NULL;
51495 }
51496
51497
51498 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51499 PyObject *resultobj = 0;
51500 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51501 int arg2 ;
51502 void *argp1 = 0 ;
51503 int res1 = 0 ;
51504 int val2 ;
51505 int ecode2 = 0 ;
51506 PyObject * obj0 = 0 ;
51507 PyObject * obj1 = 0 ;
51508 char * kwnames[] = {
51509 (char *) "self",(char *) "gap", NULL
51510 };
51511
51512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51514 if (!SWIG_IsOK(res1)) {
51515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51516 }
51517 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51518 ecode2 = SWIG_AsVal_int(obj1, &val2);
51519 if (!SWIG_IsOK(ecode2)) {
51520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51521 }
51522 arg2 = static_cast< int >(val2);
51523 {
51524 PyThreadState* __tstate = wxPyBeginAllowThreads();
51525 (arg1)->SetVGap(arg2);
51526 wxPyEndAllowThreads(__tstate);
51527 if (PyErr_Occurred()) SWIG_fail;
51528 }
51529 resultobj = SWIG_Py_Void();
51530 return resultobj;
51531 fail:
51532 return NULL;
51533 }
51534
51535
51536 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51537 PyObject *resultobj = 0;
51538 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51539 int arg2 ;
51540 void *argp1 = 0 ;
51541 int res1 = 0 ;
51542 int val2 ;
51543 int ecode2 = 0 ;
51544 PyObject * obj0 = 0 ;
51545 PyObject * obj1 = 0 ;
51546 char * kwnames[] = {
51547 (char *) "self",(char *) "gap", NULL
51548 };
51549
51550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51552 if (!SWIG_IsOK(res1)) {
51553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51554 }
51555 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51556 ecode2 = SWIG_AsVal_int(obj1, &val2);
51557 if (!SWIG_IsOK(ecode2)) {
51558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51559 }
51560 arg2 = static_cast< int >(val2);
51561 {
51562 PyThreadState* __tstate = wxPyBeginAllowThreads();
51563 (arg1)->SetHGap(arg2);
51564 wxPyEndAllowThreads(__tstate);
51565 if (PyErr_Occurred()) SWIG_fail;
51566 }
51567 resultobj = SWIG_Py_Void();
51568 return resultobj;
51569 fail:
51570 return NULL;
51571 }
51572
51573
51574 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51575 PyObject *resultobj = 0;
51576 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51577 int result;
51578 void *argp1 = 0 ;
51579 int res1 = 0 ;
51580 PyObject *swig_obj[1] ;
51581
51582 if (!args) SWIG_fail;
51583 swig_obj[0] = args;
51584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51585 if (!SWIG_IsOK(res1)) {
51586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51587 }
51588 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51589 {
51590 PyThreadState* __tstate = wxPyBeginAllowThreads();
51591 result = (int)(arg1)->GetCols();
51592 wxPyEndAllowThreads(__tstate);
51593 if (PyErr_Occurred()) SWIG_fail;
51594 }
51595 resultobj = SWIG_From_int(static_cast< int >(result));
51596 return resultobj;
51597 fail:
51598 return NULL;
51599 }
51600
51601
51602 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51603 PyObject *resultobj = 0;
51604 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51605 int result;
51606 void *argp1 = 0 ;
51607 int res1 = 0 ;
51608 PyObject *swig_obj[1] ;
51609
51610 if (!args) SWIG_fail;
51611 swig_obj[0] = args;
51612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51613 if (!SWIG_IsOK(res1)) {
51614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51615 }
51616 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51617 {
51618 PyThreadState* __tstate = wxPyBeginAllowThreads();
51619 result = (int)(arg1)->GetRows();
51620 wxPyEndAllowThreads(__tstate);
51621 if (PyErr_Occurred()) SWIG_fail;
51622 }
51623 resultobj = SWIG_From_int(static_cast< int >(result));
51624 return resultobj;
51625 fail:
51626 return NULL;
51627 }
51628
51629
51630 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51631 PyObject *resultobj = 0;
51632 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51633 int result;
51634 void *argp1 = 0 ;
51635 int res1 = 0 ;
51636 PyObject *swig_obj[1] ;
51637
51638 if (!args) SWIG_fail;
51639 swig_obj[0] = args;
51640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51641 if (!SWIG_IsOK(res1)) {
51642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51643 }
51644 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51645 {
51646 PyThreadState* __tstate = wxPyBeginAllowThreads();
51647 result = (int)(arg1)->GetVGap();
51648 wxPyEndAllowThreads(__tstate);
51649 if (PyErr_Occurred()) SWIG_fail;
51650 }
51651 resultobj = SWIG_From_int(static_cast< int >(result));
51652 return resultobj;
51653 fail:
51654 return NULL;
51655 }
51656
51657
51658 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51659 PyObject *resultobj = 0;
51660 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51661 int result;
51662 void *argp1 = 0 ;
51663 int res1 = 0 ;
51664 PyObject *swig_obj[1] ;
51665
51666 if (!args) SWIG_fail;
51667 swig_obj[0] = args;
51668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51669 if (!SWIG_IsOK(res1)) {
51670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51671 }
51672 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51673 {
51674 PyThreadState* __tstate = wxPyBeginAllowThreads();
51675 result = (int)(arg1)->GetHGap();
51676 wxPyEndAllowThreads(__tstate);
51677 if (PyErr_Occurred()) SWIG_fail;
51678 }
51679 resultobj = SWIG_From_int(static_cast< int >(result));
51680 return resultobj;
51681 fail:
51682 return NULL;
51683 }
51684
51685
51686 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51687 PyObject *obj;
51688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51689 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51690 return SWIG_Py_Void();
51691 }
51692
51693 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51694 return SWIG_Python_InitShadowInstance(args);
51695 }
51696
51697 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51698 PyObject *resultobj = 0;
51699 int arg1 = (int) 1 ;
51700 int arg2 = (int) 0 ;
51701 int arg3 = (int) 0 ;
51702 int arg4 = (int) 0 ;
51703 wxFlexGridSizer *result = 0 ;
51704 int val1 ;
51705 int ecode1 = 0 ;
51706 int val2 ;
51707 int ecode2 = 0 ;
51708 int val3 ;
51709 int ecode3 = 0 ;
51710 int val4 ;
51711 int ecode4 = 0 ;
51712 PyObject * obj0 = 0 ;
51713 PyObject * obj1 = 0 ;
51714 PyObject * obj2 = 0 ;
51715 PyObject * obj3 = 0 ;
51716 char * kwnames[] = {
51717 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51718 };
51719
51720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51721 if (obj0) {
51722 ecode1 = SWIG_AsVal_int(obj0, &val1);
51723 if (!SWIG_IsOK(ecode1)) {
51724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51725 }
51726 arg1 = static_cast< int >(val1);
51727 }
51728 if (obj1) {
51729 ecode2 = SWIG_AsVal_int(obj1, &val2);
51730 if (!SWIG_IsOK(ecode2)) {
51731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51732 }
51733 arg2 = static_cast< int >(val2);
51734 }
51735 if (obj2) {
51736 ecode3 = SWIG_AsVal_int(obj2, &val3);
51737 if (!SWIG_IsOK(ecode3)) {
51738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51739 }
51740 arg3 = static_cast< int >(val3);
51741 }
51742 if (obj3) {
51743 ecode4 = SWIG_AsVal_int(obj3, &val4);
51744 if (!SWIG_IsOK(ecode4)) {
51745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51746 }
51747 arg4 = static_cast< int >(val4);
51748 }
51749 {
51750 PyThreadState* __tstate = wxPyBeginAllowThreads();
51751 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51752 wxPyEndAllowThreads(__tstate);
51753 if (PyErr_Occurred()) SWIG_fail;
51754 }
51755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51756 return resultobj;
51757 fail:
51758 return NULL;
51759 }
51760
51761
51762 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51763 PyObject *resultobj = 0;
51764 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51765 size_t arg2 ;
51766 int arg3 = (int) 0 ;
51767 void *argp1 = 0 ;
51768 int res1 = 0 ;
51769 size_t val2 ;
51770 int ecode2 = 0 ;
51771 int val3 ;
51772 int ecode3 = 0 ;
51773 PyObject * obj0 = 0 ;
51774 PyObject * obj1 = 0 ;
51775 PyObject * obj2 = 0 ;
51776 char * kwnames[] = {
51777 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51778 };
51779
51780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51782 if (!SWIG_IsOK(res1)) {
51783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51784 }
51785 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51786 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51787 if (!SWIG_IsOK(ecode2)) {
51788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51789 }
51790 arg2 = static_cast< size_t >(val2);
51791 if (obj2) {
51792 ecode3 = SWIG_AsVal_int(obj2, &val3);
51793 if (!SWIG_IsOK(ecode3)) {
51794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51795 }
51796 arg3 = static_cast< int >(val3);
51797 }
51798 {
51799 PyThreadState* __tstate = wxPyBeginAllowThreads();
51800 (arg1)->AddGrowableRow(arg2,arg3);
51801 wxPyEndAllowThreads(__tstate);
51802 if (PyErr_Occurred()) SWIG_fail;
51803 }
51804 resultobj = SWIG_Py_Void();
51805 return resultobj;
51806 fail:
51807 return NULL;
51808 }
51809
51810
51811 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51812 PyObject *resultobj = 0;
51813 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51814 size_t arg2 ;
51815 void *argp1 = 0 ;
51816 int res1 = 0 ;
51817 size_t val2 ;
51818 int ecode2 = 0 ;
51819 PyObject * obj0 = 0 ;
51820 PyObject * obj1 = 0 ;
51821 char * kwnames[] = {
51822 (char *) "self",(char *) "idx", NULL
51823 };
51824
51825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51827 if (!SWIG_IsOK(res1)) {
51828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51829 }
51830 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51831 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51832 if (!SWIG_IsOK(ecode2)) {
51833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51834 }
51835 arg2 = static_cast< size_t >(val2);
51836 {
51837 PyThreadState* __tstate = wxPyBeginAllowThreads();
51838 (arg1)->RemoveGrowableRow(arg2);
51839 wxPyEndAllowThreads(__tstate);
51840 if (PyErr_Occurred()) SWIG_fail;
51841 }
51842 resultobj = SWIG_Py_Void();
51843 return resultobj;
51844 fail:
51845 return NULL;
51846 }
51847
51848
51849 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51850 PyObject *resultobj = 0;
51851 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51852 size_t arg2 ;
51853 int arg3 = (int) 0 ;
51854 void *argp1 = 0 ;
51855 int res1 = 0 ;
51856 size_t val2 ;
51857 int ecode2 = 0 ;
51858 int val3 ;
51859 int ecode3 = 0 ;
51860 PyObject * obj0 = 0 ;
51861 PyObject * obj1 = 0 ;
51862 PyObject * obj2 = 0 ;
51863 char * kwnames[] = {
51864 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51865 };
51866
51867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51869 if (!SWIG_IsOK(res1)) {
51870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51871 }
51872 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51873 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51874 if (!SWIG_IsOK(ecode2)) {
51875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51876 }
51877 arg2 = static_cast< size_t >(val2);
51878 if (obj2) {
51879 ecode3 = SWIG_AsVal_int(obj2, &val3);
51880 if (!SWIG_IsOK(ecode3)) {
51881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51882 }
51883 arg3 = static_cast< int >(val3);
51884 }
51885 {
51886 PyThreadState* __tstate = wxPyBeginAllowThreads();
51887 (arg1)->AddGrowableCol(arg2,arg3);
51888 wxPyEndAllowThreads(__tstate);
51889 if (PyErr_Occurred()) SWIG_fail;
51890 }
51891 resultobj = SWIG_Py_Void();
51892 return resultobj;
51893 fail:
51894 return NULL;
51895 }
51896
51897
51898 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51899 PyObject *resultobj = 0;
51900 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51901 size_t arg2 ;
51902 void *argp1 = 0 ;
51903 int res1 = 0 ;
51904 size_t val2 ;
51905 int ecode2 = 0 ;
51906 PyObject * obj0 = 0 ;
51907 PyObject * obj1 = 0 ;
51908 char * kwnames[] = {
51909 (char *) "self",(char *) "idx", NULL
51910 };
51911
51912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51914 if (!SWIG_IsOK(res1)) {
51915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51916 }
51917 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51918 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51919 if (!SWIG_IsOK(ecode2)) {
51920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51921 }
51922 arg2 = static_cast< size_t >(val2);
51923 {
51924 PyThreadState* __tstate = wxPyBeginAllowThreads();
51925 (arg1)->RemoveGrowableCol(arg2);
51926 wxPyEndAllowThreads(__tstate);
51927 if (PyErr_Occurred()) SWIG_fail;
51928 }
51929 resultobj = SWIG_Py_Void();
51930 return resultobj;
51931 fail:
51932 return NULL;
51933 }
51934
51935
51936 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51937 PyObject *resultobj = 0;
51938 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51939 int arg2 ;
51940 void *argp1 = 0 ;
51941 int res1 = 0 ;
51942 int val2 ;
51943 int ecode2 = 0 ;
51944 PyObject * obj0 = 0 ;
51945 PyObject * obj1 = 0 ;
51946 char * kwnames[] = {
51947 (char *) "self",(char *) "direction", NULL
51948 };
51949
51950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51952 if (!SWIG_IsOK(res1)) {
51953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51954 }
51955 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51956 ecode2 = SWIG_AsVal_int(obj1, &val2);
51957 if (!SWIG_IsOK(ecode2)) {
51958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51959 }
51960 arg2 = static_cast< int >(val2);
51961 {
51962 PyThreadState* __tstate = wxPyBeginAllowThreads();
51963 (arg1)->SetFlexibleDirection(arg2);
51964 wxPyEndAllowThreads(__tstate);
51965 if (PyErr_Occurred()) SWIG_fail;
51966 }
51967 resultobj = SWIG_Py_Void();
51968 return resultobj;
51969 fail:
51970 return NULL;
51971 }
51972
51973
51974 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51975 PyObject *resultobj = 0;
51976 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51977 int result;
51978 void *argp1 = 0 ;
51979 int res1 = 0 ;
51980 PyObject *swig_obj[1] ;
51981
51982 if (!args) SWIG_fail;
51983 swig_obj[0] = args;
51984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51985 if (!SWIG_IsOK(res1)) {
51986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51987 }
51988 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51989 {
51990 PyThreadState* __tstate = wxPyBeginAllowThreads();
51991 result = (int)(arg1)->GetFlexibleDirection();
51992 wxPyEndAllowThreads(__tstate);
51993 if (PyErr_Occurred()) SWIG_fail;
51994 }
51995 resultobj = SWIG_From_int(static_cast< int >(result));
51996 return resultobj;
51997 fail:
51998 return NULL;
51999 }
52000
52001
52002 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52003 PyObject *resultobj = 0;
52004 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52005 wxFlexSizerGrowMode arg2 ;
52006 void *argp1 = 0 ;
52007 int res1 = 0 ;
52008 int val2 ;
52009 int ecode2 = 0 ;
52010 PyObject * obj0 = 0 ;
52011 PyObject * obj1 = 0 ;
52012 char * kwnames[] = {
52013 (char *) "self",(char *) "mode", NULL
52014 };
52015
52016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52018 if (!SWIG_IsOK(res1)) {
52019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52020 }
52021 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52022 ecode2 = SWIG_AsVal_int(obj1, &val2);
52023 if (!SWIG_IsOK(ecode2)) {
52024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52025 }
52026 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52027 {
52028 PyThreadState* __tstate = wxPyBeginAllowThreads();
52029 (arg1)->SetNonFlexibleGrowMode(arg2);
52030 wxPyEndAllowThreads(__tstate);
52031 if (PyErr_Occurred()) SWIG_fail;
52032 }
52033 resultobj = SWIG_Py_Void();
52034 return resultobj;
52035 fail:
52036 return NULL;
52037 }
52038
52039
52040 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52041 PyObject *resultobj = 0;
52042 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52043 wxFlexSizerGrowMode result;
52044 void *argp1 = 0 ;
52045 int res1 = 0 ;
52046 PyObject *swig_obj[1] ;
52047
52048 if (!args) SWIG_fail;
52049 swig_obj[0] = args;
52050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52051 if (!SWIG_IsOK(res1)) {
52052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52053 }
52054 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52055 {
52056 PyThreadState* __tstate = wxPyBeginAllowThreads();
52057 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52058 wxPyEndAllowThreads(__tstate);
52059 if (PyErr_Occurred()) SWIG_fail;
52060 }
52061 resultobj = SWIG_From_int(static_cast< int >(result));
52062 return resultobj;
52063 fail:
52064 return NULL;
52065 }
52066
52067
52068 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52069 PyObject *resultobj = 0;
52070 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52071 wxArrayInt *result = 0 ;
52072 void *argp1 = 0 ;
52073 int res1 = 0 ;
52074 PyObject *swig_obj[1] ;
52075
52076 if (!args) SWIG_fail;
52077 swig_obj[0] = args;
52078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52079 if (!SWIG_IsOK(res1)) {
52080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52081 }
52082 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52083 {
52084 PyThreadState* __tstate = wxPyBeginAllowThreads();
52085 {
52086 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52087 result = (wxArrayInt *) &_result_ref;
52088 }
52089 wxPyEndAllowThreads(__tstate);
52090 if (PyErr_Occurred()) SWIG_fail;
52091 }
52092 {
52093 resultobj = wxArrayInt2PyList_helper(*result);
52094 }
52095 return resultobj;
52096 fail:
52097 return NULL;
52098 }
52099
52100
52101 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52102 PyObject *resultobj = 0;
52103 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52104 wxArrayInt *result = 0 ;
52105 void *argp1 = 0 ;
52106 int res1 = 0 ;
52107 PyObject *swig_obj[1] ;
52108
52109 if (!args) SWIG_fail;
52110 swig_obj[0] = args;
52111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52112 if (!SWIG_IsOK(res1)) {
52113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52114 }
52115 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52116 {
52117 PyThreadState* __tstate = wxPyBeginAllowThreads();
52118 {
52119 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52120 result = (wxArrayInt *) &_result_ref;
52121 }
52122 wxPyEndAllowThreads(__tstate);
52123 if (PyErr_Occurred()) SWIG_fail;
52124 }
52125 {
52126 resultobj = wxArrayInt2PyList_helper(*result);
52127 }
52128 return resultobj;
52129 fail:
52130 return NULL;
52131 }
52132
52133
52134 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52135 PyObject *obj;
52136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52137 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52138 return SWIG_Py_Void();
52139 }
52140
52141 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52142 return SWIG_Python_InitShadowInstance(args);
52143 }
52144
52145 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52146 PyObject *resultobj = 0;
52147 wxStdDialogButtonSizer *result = 0 ;
52148
52149 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52150 {
52151 PyThreadState* __tstate = wxPyBeginAllowThreads();
52152 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52153 wxPyEndAllowThreads(__tstate);
52154 if (PyErr_Occurred()) SWIG_fail;
52155 }
52156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52157 return resultobj;
52158 fail:
52159 return NULL;
52160 }
52161
52162
52163 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52164 PyObject *resultobj = 0;
52165 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52166 wxButton *arg2 = (wxButton *) 0 ;
52167 void *argp1 = 0 ;
52168 int res1 = 0 ;
52169 void *argp2 = 0 ;
52170 int res2 = 0 ;
52171 PyObject * obj0 = 0 ;
52172 PyObject * obj1 = 0 ;
52173 char * kwnames[] = {
52174 (char *) "self",(char *) "button", NULL
52175 };
52176
52177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52179 if (!SWIG_IsOK(res1)) {
52180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52181 }
52182 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52184 if (!SWIG_IsOK(res2)) {
52185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52186 }
52187 arg2 = reinterpret_cast< wxButton * >(argp2);
52188 {
52189 PyThreadState* __tstate = wxPyBeginAllowThreads();
52190 (arg1)->AddButton(arg2);
52191 wxPyEndAllowThreads(__tstate);
52192 if (PyErr_Occurred()) SWIG_fail;
52193 }
52194 resultobj = SWIG_Py_Void();
52195 return resultobj;
52196 fail:
52197 return NULL;
52198 }
52199
52200
52201 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52202 PyObject *resultobj = 0;
52203 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52204 void *argp1 = 0 ;
52205 int res1 = 0 ;
52206 PyObject *swig_obj[1] ;
52207
52208 if (!args) SWIG_fail;
52209 swig_obj[0] = args;
52210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52211 if (!SWIG_IsOK(res1)) {
52212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52213 }
52214 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52215 {
52216 PyThreadState* __tstate = wxPyBeginAllowThreads();
52217 (arg1)->Realize();
52218 wxPyEndAllowThreads(__tstate);
52219 if (PyErr_Occurred()) SWIG_fail;
52220 }
52221 resultobj = SWIG_Py_Void();
52222 return resultobj;
52223 fail:
52224 return NULL;
52225 }
52226
52227
52228 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52229 PyObject *resultobj = 0;
52230 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52231 wxButton *arg2 = (wxButton *) 0 ;
52232 void *argp1 = 0 ;
52233 int res1 = 0 ;
52234 void *argp2 = 0 ;
52235 int res2 = 0 ;
52236 PyObject * obj0 = 0 ;
52237 PyObject * obj1 = 0 ;
52238 char * kwnames[] = {
52239 (char *) "self",(char *) "button", NULL
52240 };
52241
52242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52244 if (!SWIG_IsOK(res1)) {
52245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52246 }
52247 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52249 if (!SWIG_IsOK(res2)) {
52250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52251 }
52252 arg2 = reinterpret_cast< wxButton * >(argp2);
52253 {
52254 PyThreadState* __tstate = wxPyBeginAllowThreads();
52255 (arg1)->SetAffirmativeButton(arg2);
52256 wxPyEndAllowThreads(__tstate);
52257 if (PyErr_Occurred()) SWIG_fail;
52258 }
52259 resultobj = SWIG_Py_Void();
52260 return resultobj;
52261 fail:
52262 return NULL;
52263 }
52264
52265
52266 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52267 PyObject *resultobj = 0;
52268 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52269 wxButton *arg2 = (wxButton *) 0 ;
52270 void *argp1 = 0 ;
52271 int res1 = 0 ;
52272 void *argp2 = 0 ;
52273 int res2 = 0 ;
52274 PyObject * obj0 = 0 ;
52275 PyObject * obj1 = 0 ;
52276 char * kwnames[] = {
52277 (char *) "self",(char *) "button", NULL
52278 };
52279
52280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52282 if (!SWIG_IsOK(res1)) {
52283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52284 }
52285 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52287 if (!SWIG_IsOK(res2)) {
52288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52289 }
52290 arg2 = reinterpret_cast< wxButton * >(argp2);
52291 {
52292 PyThreadState* __tstate = wxPyBeginAllowThreads();
52293 (arg1)->SetNegativeButton(arg2);
52294 wxPyEndAllowThreads(__tstate);
52295 if (PyErr_Occurred()) SWIG_fail;
52296 }
52297 resultobj = SWIG_Py_Void();
52298 return resultobj;
52299 fail:
52300 return NULL;
52301 }
52302
52303
52304 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52305 PyObject *resultobj = 0;
52306 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52307 wxButton *arg2 = (wxButton *) 0 ;
52308 void *argp1 = 0 ;
52309 int res1 = 0 ;
52310 void *argp2 = 0 ;
52311 int res2 = 0 ;
52312 PyObject * obj0 = 0 ;
52313 PyObject * obj1 = 0 ;
52314 char * kwnames[] = {
52315 (char *) "self",(char *) "button", NULL
52316 };
52317
52318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52320 if (!SWIG_IsOK(res1)) {
52321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52322 }
52323 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52324 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52325 if (!SWIG_IsOK(res2)) {
52326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52327 }
52328 arg2 = reinterpret_cast< wxButton * >(argp2);
52329 {
52330 PyThreadState* __tstate = wxPyBeginAllowThreads();
52331 (arg1)->SetCancelButton(arg2);
52332 wxPyEndAllowThreads(__tstate);
52333 if (PyErr_Occurred()) SWIG_fail;
52334 }
52335 resultobj = SWIG_Py_Void();
52336 return resultobj;
52337 fail:
52338 return NULL;
52339 }
52340
52341
52342 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52343 PyObject *resultobj = 0;
52344 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52345 wxButton *result = 0 ;
52346 void *argp1 = 0 ;
52347 int res1 = 0 ;
52348 PyObject *swig_obj[1] ;
52349
52350 if (!args) SWIG_fail;
52351 swig_obj[0] = args;
52352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52353 if (!SWIG_IsOK(res1)) {
52354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52355 }
52356 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52357 {
52358 PyThreadState* __tstate = wxPyBeginAllowThreads();
52359 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52360 wxPyEndAllowThreads(__tstate);
52361 if (PyErr_Occurred()) SWIG_fail;
52362 }
52363 {
52364 resultobj = wxPyMake_wxObject(result, (bool)0);
52365 }
52366 return resultobj;
52367 fail:
52368 return NULL;
52369 }
52370
52371
52372 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52373 PyObject *resultobj = 0;
52374 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52375 wxButton *result = 0 ;
52376 void *argp1 = 0 ;
52377 int res1 = 0 ;
52378 PyObject *swig_obj[1] ;
52379
52380 if (!args) SWIG_fail;
52381 swig_obj[0] = args;
52382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52383 if (!SWIG_IsOK(res1)) {
52384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52385 }
52386 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52387 {
52388 PyThreadState* __tstate = wxPyBeginAllowThreads();
52389 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52390 wxPyEndAllowThreads(__tstate);
52391 if (PyErr_Occurred()) SWIG_fail;
52392 }
52393 {
52394 resultobj = wxPyMake_wxObject(result, (bool)0);
52395 }
52396 return resultobj;
52397 fail:
52398 return NULL;
52399 }
52400
52401
52402 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52403 PyObject *resultobj = 0;
52404 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52405 wxButton *result = 0 ;
52406 void *argp1 = 0 ;
52407 int res1 = 0 ;
52408 PyObject *swig_obj[1] ;
52409
52410 if (!args) SWIG_fail;
52411 swig_obj[0] = args;
52412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52413 if (!SWIG_IsOK(res1)) {
52414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52415 }
52416 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52417 {
52418 PyThreadState* __tstate = wxPyBeginAllowThreads();
52419 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52420 wxPyEndAllowThreads(__tstate);
52421 if (PyErr_Occurred()) SWIG_fail;
52422 }
52423 {
52424 resultobj = wxPyMake_wxObject(result, (bool)0);
52425 }
52426 return resultobj;
52427 fail:
52428 return NULL;
52429 }
52430
52431
52432 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52433 PyObject *resultobj = 0;
52434 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52435 wxButton *result = 0 ;
52436 void *argp1 = 0 ;
52437 int res1 = 0 ;
52438 PyObject *swig_obj[1] ;
52439
52440 if (!args) SWIG_fail;
52441 swig_obj[0] = args;
52442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52443 if (!SWIG_IsOK(res1)) {
52444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52445 }
52446 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52447 {
52448 PyThreadState* __tstate = wxPyBeginAllowThreads();
52449 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52450 wxPyEndAllowThreads(__tstate);
52451 if (PyErr_Occurred()) SWIG_fail;
52452 }
52453 {
52454 resultobj = wxPyMake_wxObject(result, (bool)0);
52455 }
52456 return resultobj;
52457 fail:
52458 return NULL;
52459 }
52460
52461
52462 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52463 PyObject *resultobj = 0;
52464 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52465 wxButton *result = 0 ;
52466 void *argp1 = 0 ;
52467 int res1 = 0 ;
52468 PyObject *swig_obj[1] ;
52469
52470 if (!args) SWIG_fail;
52471 swig_obj[0] = args;
52472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52473 if (!SWIG_IsOK(res1)) {
52474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52475 }
52476 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52477 {
52478 PyThreadState* __tstate = wxPyBeginAllowThreads();
52479 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52480 wxPyEndAllowThreads(__tstate);
52481 if (PyErr_Occurred()) SWIG_fail;
52482 }
52483 {
52484 resultobj = wxPyMake_wxObject(result, (bool)0);
52485 }
52486 return resultobj;
52487 fail:
52488 return NULL;
52489 }
52490
52491
52492 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52493 PyObject *obj;
52494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52495 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52496 return SWIG_Py_Void();
52497 }
52498
52499 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52500 return SWIG_Python_InitShadowInstance(args);
52501 }
52502
52503 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52504 PyObject *resultobj = 0;
52505 int arg1 = (int) 0 ;
52506 int arg2 = (int) 0 ;
52507 wxGBPosition *result = 0 ;
52508 int val1 ;
52509 int ecode1 = 0 ;
52510 int val2 ;
52511 int ecode2 = 0 ;
52512 PyObject * obj0 = 0 ;
52513 PyObject * obj1 = 0 ;
52514 char * kwnames[] = {
52515 (char *) "row",(char *) "col", NULL
52516 };
52517
52518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52519 if (obj0) {
52520 ecode1 = SWIG_AsVal_int(obj0, &val1);
52521 if (!SWIG_IsOK(ecode1)) {
52522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52523 }
52524 arg1 = static_cast< int >(val1);
52525 }
52526 if (obj1) {
52527 ecode2 = SWIG_AsVal_int(obj1, &val2);
52528 if (!SWIG_IsOK(ecode2)) {
52529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52530 }
52531 arg2 = static_cast< int >(val2);
52532 }
52533 {
52534 PyThreadState* __tstate = wxPyBeginAllowThreads();
52535 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52536 wxPyEndAllowThreads(__tstate);
52537 if (PyErr_Occurred()) SWIG_fail;
52538 }
52539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52540 return resultobj;
52541 fail:
52542 return NULL;
52543 }
52544
52545
52546 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52547 PyObject *resultobj = 0;
52548 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52549 void *argp1 = 0 ;
52550 int res1 = 0 ;
52551 PyObject *swig_obj[1] ;
52552
52553 if (!args) SWIG_fail;
52554 swig_obj[0] = args;
52555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52556 if (!SWIG_IsOK(res1)) {
52557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52558 }
52559 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52560 {
52561 PyThreadState* __tstate = wxPyBeginAllowThreads();
52562 delete arg1;
52563
52564 wxPyEndAllowThreads(__tstate);
52565 if (PyErr_Occurred()) SWIG_fail;
52566 }
52567 resultobj = SWIG_Py_Void();
52568 return resultobj;
52569 fail:
52570 return NULL;
52571 }
52572
52573
52574 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52575 PyObject *resultobj = 0;
52576 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52577 int result;
52578 void *argp1 = 0 ;
52579 int res1 = 0 ;
52580 PyObject *swig_obj[1] ;
52581
52582 if (!args) SWIG_fail;
52583 swig_obj[0] = args;
52584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52585 if (!SWIG_IsOK(res1)) {
52586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52587 }
52588 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52589 {
52590 PyThreadState* __tstate = wxPyBeginAllowThreads();
52591 result = (int)((wxGBPosition const *)arg1)->GetRow();
52592 wxPyEndAllowThreads(__tstate);
52593 if (PyErr_Occurred()) SWIG_fail;
52594 }
52595 resultobj = SWIG_From_int(static_cast< int >(result));
52596 return resultobj;
52597 fail:
52598 return NULL;
52599 }
52600
52601
52602 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52603 PyObject *resultobj = 0;
52604 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52605 int result;
52606 void *argp1 = 0 ;
52607 int res1 = 0 ;
52608 PyObject *swig_obj[1] ;
52609
52610 if (!args) SWIG_fail;
52611 swig_obj[0] = args;
52612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52613 if (!SWIG_IsOK(res1)) {
52614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52615 }
52616 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52617 {
52618 PyThreadState* __tstate = wxPyBeginAllowThreads();
52619 result = (int)((wxGBPosition const *)arg1)->GetCol();
52620 wxPyEndAllowThreads(__tstate);
52621 if (PyErr_Occurred()) SWIG_fail;
52622 }
52623 resultobj = SWIG_From_int(static_cast< int >(result));
52624 return resultobj;
52625 fail:
52626 return NULL;
52627 }
52628
52629
52630 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52631 PyObject *resultobj = 0;
52632 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52633 int arg2 ;
52634 void *argp1 = 0 ;
52635 int res1 = 0 ;
52636 int val2 ;
52637 int ecode2 = 0 ;
52638 PyObject * obj0 = 0 ;
52639 PyObject * obj1 = 0 ;
52640 char * kwnames[] = {
52641 (char *) "self",(char *) "row", NULL
52642 };
52643
52644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52646 if (!SWIG_IsOK(res1)) {
52647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52648 }
52649 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52650 ecode2 = SWIG_AsVal_int(obj1, &val2);
52651 if (!SWIG_IsOK(ecode2)) {
52652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52653 }
52654 arg2 = static_cast< int >(val2);
52655 {
52656 PyThreadState* __tstate = wxPyBeginAllowThreads();
52657 (arg1)->SetRow(arg2);
52658 wxPyEndAllowThreads(__tstate);
52659 if (PyErr_Occurred()) SWIG_fail;
52660 }
52661 resultobj = SWIG_Py_Void();
52662 return resultobj;
52663 fail:
52664 return NULL;
52665 }
52666
52667
52668 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52669 PyObject *resultobj = 0;
52670 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52671 int arg2 ;
52672 void *argp1 = 0 ;
52673 int res1 = 0 ;
52674 int val2 ;
52675 int ecode2 = 0 ;
52676 PyObject * obj0 = 0 ;
52677 PyObject * obj1 = 0 ;
52678 char * kwnames[] = {
52679 (char *) "self",(char *) "col", NULL
52680 };
52681
52682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52684 if (!SWIG_IsOK(res1)) {
52685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52686 }
52687 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52688 ecode2 = SWIG_AsVal_int(obj1, &val2);
52689 if (!SWIG_IsOK(ecode2)) {
52690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52691 }
52692 arg2 = static_cast< int >(val2);
52693 {
52694 PyThreadState* __tstate = wxPyBeginAllowThreads();
52695 (arg1)->SetCol(arg2);
52696 wxPyEndAllowThreads(__tstate);
52697 if (PyErr_Occurred()) SWIG_fail;
52698 }
52699 resultobj = SWIG_Py_Void();
52700 return resultobj;
52701 fail:
52702 return NULL;
52703 }
52704
52705
52706 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52707 PyObject *resultobj = 0;
52708 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52709 PyObject *arg2 = (PyObject *) 0 ;
52710 bool result;
52711 void *argp1 = 0 ;
52712 int res1 = 0 ;
52713 PyObject * obj0 = 0 ;
52714 PyObject * obj1 = 0 ;
52715 char * kwnames[] = {
52716 (char *) "self",(char *) "other", NULL
52717 };
52718
52719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52721 if (!SWIG_IsOK(res1)) {
52722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52723 }
52724 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52725 arg2 = obj1;
52726 {
52727 result = (bool)wxGBPosition___eq__(arg1,arg2);
52728 if (PyErr_Occurred()) SWIG_fail;
52729 }
52730 {
52731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52732 }
52733 return resultobj;
52734 fail:
52735 return NULL;
52736 }
52737
52738
52739 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52740 PyObject *resultobj = 0;
52741 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52742 PyObject *arg2 = (PyObject *) 0 ;
52743 bool result;
52744 void *argp1 = 0 ;
52745 int res1 = 0 ;
52746 PyObject * obj0 = 0 ;
52747 PyObject * obj1 = 0 ;
52748 char * kwnames[] = {
52749 (char *) "self",(char *) "other", NULL
52750 };
52751
52752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52754 if (!SWIG_IsOK(res1)) {
52755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52756 }
52757 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52758 arg2 = obj1;
52759 {
52760 result = (bool)wxGBPosition___ne__(arg1,arg2);
52761 if (PyErr_Occurred()) SWIG_fail;
52762 }
52763 {
52764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52765 }
52766 return resultobj;
52767 fail:
52768 return NULL;
52769 }
52770
52771
52772 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52773 PyObject *resultobj = 0;
52774 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52775 int arg2 = (int) 0 ;
52776 int arg3 = (int) 0 ;
52777 void *argp1 = 0 ;
52778 int res1 = 0 ;
52779 int val2 ;
52780 int ecode2 = 0 ;
52781 int val3 ;
52782 int ecode3 = 0 ;
52783 PyObject * obj0 = 0 ;
52784 PyObject * obj1 = 0 ;
52785 PyObject * obj2 = 0 ;
52786 char * kwnames[] = {
52787 (char *) "self",(char *) "row",(char *) "col", NULL
52788 };
52789
52790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52792 if (!SWIG_IsOK(res1)) {
52793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52794 }
52795 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52796 if (obj1) {
52797 ecode2 = SWIG_AsVal_int(obj1, &val2);
52798 if (!SWIG_IsOK(ecode2)) {
52799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52800 }
52801 arg2 = static_cast< int >(val2);
52802 }
52803 if (obj2) {
52804 ecode3 = SWIG_AsVal_int(obj2, &val3);
52805 if (!SWIG_IsOK(ecode3)) {
52806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52807 }
52808 arg3 = static_cast< int >(val3);
52809 }
52810 {
52811 PyThreadState* __tstate = wxPyBeginAllowThreads();
52812 wxGBPosition_Set(arg1,arg2,arg3);
52813 wxPyEndAllowThreads(__tstate);
52814 if (PyErr_Occurred()) SWIG_fail;
52815 }
52816 resultobj = SWIG_Py_Void();
52817 return resultobj;
52818 fail:
52819 return NULL;
52820 }
52821
52822
52823 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52824 PyObject *resultobj = 0;
52825 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52826 PyObject *result = 0 ;
52827 void *argp1 = 0 ;
52828 int res1 = 0 ;
52829 PyObject *swig_obj[1] ;
52830
52831 if (!args) SWIG_fail;
52832 swig_obj[0] = args;
52833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52834 if (!SWIG_IsOK(res1)) {
52835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52836 }
52837 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52838 {
52839 PyThreadState* __tstate = wxPyBeginAllowThreads();
52840 result = (PyObject *)wxGBPosition_Get(arg1);
52841 wxPyEndAllowThreads(__tstate);
52842 if (PyErr_Occurred()) SWIG_fail;
52843 }
52844 resultobj = result;
52845 return resultobj;
52846 fail:
52847 return NULL;
52848 }
52849
52850
52851 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52852 PyObject *obj;
52853 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52854 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52855 return SWIG_Py_Void();
52856 }
52857
52858 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52859 return SWIG_Python_InitShadowInstance(args);
52860 }
52861
52862 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52863 PyObject *resultobj = 0;
52864 int arg1 = (int) 1 ;
52865 int arg2 = (int) 1 ;
52866 wxGBSpan *result = 0 ;
52867 int val1 ;
52868 int ecode1 = 0 ;
52869 int val2 ;
52870 int ecode2 = 0 ;
52871 PyObject * obj0 = 0 ;
52872 PyObject * obj1 = 0 ;
52873 char * kwnames[] = {
52874 (char *) "rowspan",(char *) "colspan", NULL
52875 };
52876
52877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52878 if (obj0) {
52879 ecode1 = SWIG_AsVal_int(obj0, &val1);
52880 if (!SWIG_IsOK(ecode1)) {
52881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52882 }
52883 arg1 = static_cast< int >(val1);
52884 }
52885 if (obj1) {
52886 ecode2 = SWIG_AsVal_int(obj1, &val2);
52887 if (!SWIG_IsOK(ecode2)) {
52888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52889 }
52890 arg2 = static_cast< int >(val2);
52891 }
52892 {
52893 PyThreadState* __tstate = wxPyBeginAllowThreads();
52894 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52895 wxPyEndAllowThreads(__tstate);
52896 if (PyErr_Occurred()) SWIG_fail;
52897 }
52898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52899 return resultobj;
52900 fail:
52901 return NULL;
52902 }
52903
52904
52905 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52906 PyObject *resultobj = 0;
52907 wxGBSpan *arg1 = (wxGBSpan *) 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_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52915 if (!SWIG_IsOK(res1)) {
52916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52917 }
52918 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52919 {
52920 PyThreadState* __tstate = wxPyBeginAllowThreads();
52921 delete arg1;
52922
52923 wxPyEndAllowThreads(__tstate);
52924 if (PyErr_Occurred()) SWIG_fail;
52925 }
52926 resultobj = SWIG_Py_Void();
52927 return resultobj;
52928 fail:
52929 return NULL;
52930 }
52931
52932
52933 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52934 PyObject *resultobj = 0;
52935 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52936 int result;
52937 void *argp1 = 0 ;
52938 int res1 = 0 ;
52939 PyObject *swig_obj[1] ;
52940
52941 if (!args) SWIG_fail;
52942 swig_obj[0] = args;
52943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52944 if (!SWIG_IsOK(res1)) {
52945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52946 }
52947 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52948 {
52949 PyThreadState* __tstate = wxPyBeginAllowThreads();
52950 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52951 wxPyEndAllowThreads(__tstate);
52952 if (PyErr_Occurred()) SWIG_fail;
52953 }
52954 resultobj = SWIG_From_int(static_cast< int >(result));
52955 return resultobj;
52956 fail:
52957 return NULL;
52958 }
52959
52960
52961 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52962 PyObject *resultobj = 0;
52963 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52964 int result;
52965 void *argp1 = 0 ;
52966 int res1 = 0 ;
52967 PyObject *swig_obj[1] ;
52968
52969 if (!args) SWIG_fail;
52970 swig_obj[0] = args;
52971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52972 if (!SWIG_IsOK(res1)) {
52973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52974 }
52975 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52976 {
52977 PyThreadState* __tstate = wxPyBeginAllowThreads();
52978 result = (int)((wxGBSpan const *)arg1)->GetColspan();
52979 wxPyEndAllowThreads(__tstate);
52980 if (PyErr_Occurred()) SWIG_fail;
52981 }
52982 resultobj = SWIG_From_int(static_cast< int >(result));
52983 return resultobj;
52984 fail:
52985 return NULL;
52986 }
52987
52988
52989 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52990 PyObject *resultobj = 0;
52991 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52992 int arg2 ;
52993 void *argp1 = 0 ;
52994 int res1 = 0 ;
52995 int val2 ;
52996 int ecode2 = 0 ;
52997 PyObject * obj0 = 0 ;
52998 PyObject * obj1 = 0 ;
52999 char * kwnames[] = {
53000 (char *) "self",(char *) "rowspan", NULL
53001 };
53002
53003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53005 if (!SWIG_IsOK(res1)) {
53006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53007 }
53008 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53009 ecode2 = SWIG_AsVal_int(obj1, &val2);
53010 if (!SWIG_IsOK(ecode2)) {
53011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53012 }
53013 arg2 = static_cast< int >(val2);
53014 {
53015 PyThreadState* __tstate = wxPyBeginAllowThreads();
53016 (arg1)->SetRowspan(arg2);
53017 wxPyEndAllowThreads(__tstate);
53018 if (PyErr_Occurred()) SWIG_fail;
53019 }
53020 resultobj = SWIG_Py_Void();
53021 return resultobj;
53022 fail:
53023 return NULL;
53024 }
53025
53026
53027 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53028 PyObject *resultobj = 0;
53029 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53030 int arg2 ;
53031 void *argp1 = 0 ;
53032 int res1 = 0 ;
53033 int val2 ;
53034 int ecode2 = 0 ;
53035 PyObject * obj0 = 0 ;
53036 PyObject * obj1 = 0 ;
53037 char * kwnames[] = {
53038 (char *) "self",(char *) "colspan", NULL
53039 };
53040
53041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53043 if (!SWIG_IsOK(res1)) {
53044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53045 }
53046 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53047 ecode2 = SWIG_AsVal_int(obj1, &val2);
53048 if (!SWIG_IsOK(ecode2)) {
53049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53050 }
53051 arg2 = static_cast< int >(val2);
53052 {
53053 PyThreadState* __tstate = wxPyBeginAllowThreads();
53054 (arg1)->SetColspan(arg2);
53055 wxPyEndAllowThreads(__tstate);
53056 if (PyErr_Occurred()) SWIG_fail;
53057 }
53058 resultobj = SWIG_Py_Void();
53059 return resultobj;
53060 fail:
53061 return NULL;
53062 }
53063
53064
53065 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53066 PyObject *resultobj = 0;
53067 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53068 PyObject *arg2 = (PyObject *) 0 ;
53069 bool result;
53070 void *argp1 = 0 ;
53071 int res1 = 0 ;
53072 PyObject * obj0 = 0 ;
53073 PyObject * obj1 = 0 ;
53074 char * kwnames[] = {
53075 (char *) "self",(char *) "other", NULL
53076 };
53077
53078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53080 if (!SWIG_IsOK(res1)) {
53081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53082 }
53083 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53084 arg2 = obj1;
53085 {
53086 result = (bool)wxGBSpan___eq__(arg1,arg2);
53087 if (PyErr_Occurred()) SWIG_fail;
53088 }
53089 {
53090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53091 }
53092 return resultobj;
53093 fail:
53094 return NULL;
53095 }
53096
53097
53098 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53099 PyObject *resultobj = 0;
53100 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53101 PyObject *arg2 = (PyObject *) 0 ;
53102 bool result;
53103 void *argp1 = 0 ;
53104 int res1 = 0 ;
53105 PyObject * obj0 = 0 ;
53106 PyObject * obj1 = 0 ;
53107 char * kwnames[] = {
53108 (char *) "self",(char *) "other", NULL
53109 };
53110
53111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53113 if (!SWIG_IsOK(res1)) {
53114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53115 }
53116 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53117 arg2 = obj1;
53118 {
53119 result = (bool)wxGBSpan___ne__(arg1,arg2);
53120 if (PyErr_Occurred()) SWIG_fail;
53121 }
53122 {
53123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53124 }
53125 return resultobj;
53126 fail:
53127 return NULL;
53128 }
53129
53130
53131 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53132 PyObject *resultobj = 0;
53133 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53134 int arg2 = (int) 1 ;
53135 int arg3 = (int) 1 ;
53136 void *argp1 = 0 ;
53137 int res1 = 0 ;
53138 int val2 ;
53139 int ecode2 = 0 ;
53140 int val3 ;
53141 int ecode3 = 0 ;
53142 PyObject * obj0 = 0 ;
53143 PyObject * obj1 = 0 ;
53144 PyObject * obj2 = 0 ;
53145 char * kwnames[] = {
53146 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53147 };
53148
53149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53151 if (!SWIG_IsOK(res1)) {
53152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53153 }
53154 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53155 if (obj1) {
53156 ecode2 = SWIG_AsVal_int(obj1, &val2);
53157 if (!SWIG_IsOK(ecode2)) {
53158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53159 }
53160 arg2 = static_cast< int >(val2);
53161 }
53162 if (obj2) {
53163 ecode3 = SWIG_AsVal_int(obj2, &val3);
53164 if (!SWIG_IsOK(ecode3)) {
53165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53166 }
53167 arg3 = static_cast< int >(val3);
53168 }
53169 {
53170 PyThreadState* __tstate = wxPyBeginAllowThreads();
53171 wxGBSpan_Set(arg1,arg2,arg3);
53172 wxPyEndAllowThreads(__tstate);
53173 if (PyErr_Occurred()) SWIG_fail;
53174 }
53175 resultobj = SWIG_Py_Void();
53176 return resultobj;
53177 fail:
53178 return NULL;
53179 }
53180
53181
53182 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53183 PyObject *resultobj = 0;
53184 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53185 PyObject *result = 0 ;
53186 void *argp1 = 0 ;
53187 int res1 = 0 ;
53188 PyObject *swig_obj[1] ;
53189
53190 if (!args) SWIG_fail;
53191 swig_obj[0] = args;
53192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53193 if (!SWIG_IsOK(res1)) {
53194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53195 }
53196 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53197 {
53198 PyThreadState* __tstate = wxPyBeginAllowThreads();
53199 result = (PyObject *)wxGBSpan_Get(arg1);
53200 wxPyEndAllowThreads(__tstate);
53201 if (PyErr_Occurred()) SWIG_fail;
53202 }
53203 resultobj = result;
53204 return resultobj;
53205 fail:
53206 return NULL;
53207 }
53208
53209
53210 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53211 PyObject *obj;
53212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53213 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53214 return SWIG_Py_Void();
53215 }
53216
53217 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53218 return SWIG_Python_InitShadowInstance(args);
53219 }
53220
53221 SWIGINTERN int DefaultSpan_set(PyObject *) {
53222 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53223 return 1;
53224 }
53225
53226
53227 SWIGINTERN PyObject *DefaultSpan_get(void) {
53228 PyObject *pyobj = 0;
53229
53230 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53231 return pyobj;
53232 }
53233
53234
53235 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53236 PyObject *resultobj = 0;
53237 wxGBSizerItem *result = 0 ;
53238
53239 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53240 {
53241 PyThreadState* __tstate = wxPyBeginAllowThreads();
53242 result = (wxGBSizerItem *)new wxGBSizerItem();
53243 wxPyEndAllowThreads(__tstate);
53244 if (PyErr_Occurred()) SWIG_fail;
53245 }
53246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53247 return resultobj;
53248 fail:
53249 return NULL;
53250 }
53251
53252
53253 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53254 PyObject *resultobj = 0;
53255 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53256 void *argp1 = 0 ;
53257 int res1 = 0 ;
53258 PyObject *swig_obj[1] ;
53259
53260 if (!args) SWIG_fail;
53261 swig_obj[0] = args;
53262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53263 if (!SWIG_IsOK(res1)) {
53264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53265 }
53266 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53267 {
53268 PyThreadState* __tstate = wxPyBeginAllowThreads();
53269 delete arg1;
53270
53271 wxPyEndAllowThreads(__tstate);
53272 if (PyErr_Occurred()) SWIG_fail;
53273 }
53274 resultobj = SWIG_Py_Void();
53275 return resultobj;
53276 fail:
53277 return NULL;
53278 }
53279
53280
53281 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53282 PyObject *resultobj = 0;
53283 wxWindow *arg1 = (wxWindow *) 0 ;
53284 wxGBPosition *arg2 = 0 ;
53285 wxGBSpan *arg3 = 0 ;
53286 int arg4 ;
53287 int arg5 ;
53288 PyObject *arg6 = (PyObject *) NULL ;
53289 wxGBSizerItem *result = 0 ;
53290 void *argp1 = 0 ;
53291 int res1 = 0 ;
53292 wxGBPosition temp2 ;
53293 wxGBSpan temp3 ;
53294 int val4 ;
53295 int ecode4 = 0 ;
53296 int val5 ;
53297 int ecode5 = 0 ;
53298 PyObject * obj0 = 0 ;
53299 PyObject * obj1 = 0 ;
53300 PyObject * obj2 = 0 ;
53301 PyObject * obj3 = 0 ;
53302 PyObject * obj4 = 0 ;
53303 PyObject * obj5 = 0 ;
53304 char * kwnames[] = {
53305 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53306 };
53307
53308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53310 if (!SWIG_IsOK(res1)) {
53311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53312 }
53313 arg1 = reinterpret_cast< wxWindow * >(argp1);
53314 {
53315 arg2 = &temp2;
53316 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53317 }
53318 {
53319 arg3 = &temp3;
53320 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53321 }
53322 ecode4 = SWIG_AsVal_int(obj3, &val4);
53323 if (!SWIG_IsOK(ecode4)) {
53324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53325 }
53326 arg4 = static_cast< int >(val4);
53327 ecode5 = SWIG_AsVal_int(obj4, &val5);
53328 if (!SWIG_IsOK(ecode5)) {
53329 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53330 }
53331 arg5 = static_cast< int >(val5);
53332 if (obj5) {
53333 arg6 = obj5;
53334 }
53335 {
53336 PyThreadState* __tstate = wxPyBeginAllowThreads();
53337 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53338 wxPyEndAllowThreads(__tstate);
53339 if (PyErr_Occurred()) SWIG_fail;
53340 }
53341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53342 return resultobj;
53343 fail:
53344 return NULL;
53345 }
53346
53347
53348 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53349 PyObject *resultobj = 0;
53350 wxSizer *arg1 = (wxSizer *) 0 ;
53351 wxGBPosition *arg2 = 0 ;
53352 wxGBSpan *arg3 = 0 ;
53353 int arg4 ;
53354 int arg5 ;
53355 PyObject *arg6 = (PyObject *) NULL ;
53356 wxGBSizerItem *result = 0 ;
53357 int res1 = 0 ;
53358 wxGBPosition temp2 ;
53359 wxGBSpan temp3 ;
53360 int val4 ;
53361 int ecode4 = 0 ;
53362 int val5 ;
53363 int ecode5 = 0 ;
53364 PyObject * obj0 = 0 ;
53365 PyObject * obj1 = 0 ;
53366 PyObject * obj2 = 0 ;
53367 PyObject * obj3 = 0 ;
53368 PyObject * obj4 = 0 ;
53369 PyObject * obj5 = 0 ;
53370 char * kwnames[] = {
53371 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53372 };
53373
53374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53375 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53376 if (!SWIG_IsOK(res1)) {
53377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53378 }
53379 {
53380 arg2 = &temp2;
53381 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53382 }
53383 {
53384 arg3 = &temp3;
53385 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53386 }
53387 ecode4 = SWIG_AsVal_int(obj3, &val4);
53388 if (!SWIG_IsOK(ecode4)) {
53389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53390 }
53391 arg4 = static_cast< int >(val4);
53392 ecode5 = SWIG_AsVal_int(obj4, &val5);
53393 if (!SWIG_IsOK(ecode5)) {
53394 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53395 }
53396 arg5 = static_cast< int >(val5);
53397 if (obj5) {
53398 arg6 = obj5;
53399 }
53400 {
53401 PyThreadState* __tstate = wxPyBeginAllowThreads();
53402 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53403 wxPyEndAllowThreads(__tstate);
53404 if (PyErr_Occurred()) SWIG_fail;
53405 }
53406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53407 return resultobj;
53408 fail:
53409 return NULL;
53410 }
53411
53412
53413 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53414 PyObject *resultobj = 0;
53415 int arg1 ;
53416 int arg2 ;
53417 wxGBPosition *arg3 = 0 ;
53418 wxGBSpan *arg4 = 0 ;
53419 int arg5 ;
53420 int arg6 ;
53421 PyObject *arg7 = (PyObject *) NULL ;
53422 wxGBSizerItem *result = 0 ;
53423 int val1 ;
53424 int ecode1 = 0 ;
53425 int val2 ;
53426 int ecode2 = 0 ;
53427 wxGBPosition temp3 ;
53428 wxGBSpan temp4 ;
53429 int val5 ;
53430 int ecode5 = 0 ;
53431 int val6 ;
53432 int ecode6 = 0 ;
53433 PyObject * obj0 = 0 ;
53434 PyObject * obj1 = 0 ;
53435 PyObject * obj2 = 0 ;
53436 PyObject * obj3 = 0 ;
53437 PyObject * obj4 = 0 ;
53438 PyObject * obj5 = 0 ;
53439 PyObject * obj6 = 0 ;
53440 char * kwnames[] = {
53441 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53442 };
53443
53444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53445 ecode1 = SWIG_AsVal_int(obj0, &val1);
53446 if (!SWIG_IsOK(ecode1)) {
53447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53448 }
53449 arg1 = static_cast< int >(val1);
53450 ecode2 = SWIG_AsVal_int(obj1, &val2);
53451 if (!SWIG_IsOK(ecode2)) {
53452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53453 }
53454 arg2 = static_cast< int >(val2);
53455 {
53456 arg3 = &temp3;
53457 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53458 }
53459 {
53460 arg4 = &temp4;
53461 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53462 }
53463 ecode5 = SWIG_AsVal_int(obj4, &val5);
53464 if (!SWIG_IsOK(ecode5)) {
53465 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53466 }
53467 arg5 = static_cast< int >(val5);
53468 ecode6 = SWIG_AsVal_int(obj5, &val6);
53469 if (!SWIG_IsOK(ecode6)) {
53470 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53471 }
53472 arg6 = static_cast< int >(val6);
53473 if (obj6) {
53474 arg7 = obj6;
53475 }
53476 {
53477 PyThreadState* __tstate = wxPyBeginAllowThreads();
53478 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53479 wxPyEndAllowThreads(__tstate);
53480 if (PyErr_Occurred()) SWIG_fail;
53481 }
53482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53483 return resultobj;
53484 fail:
53485 return NULL;
53486 }
53487
53488
53489 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53490 PyObject *resultobj = 0;
53491 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53492 wxGBPosition result;
53493 void *argp1 = 0 ;
53494 int res1 = 0 ;
53495 PyObject *swig_obj[1] ;
53496
53497 if (!args) SWIG_fail;
53498 swig_obj[0] = args;
53499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53500 if (!SWIG_IsOK(res1)) {
53501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53502 }
53503 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53504 {
53505 PyThreadState* __tstate = wxPyBeginAllowThreads();
53506 result = ((wxGBSizerItem const *)arg1)->GetPos();
53507 wxPyEndAllowThreads(__tstate);
53508 if (PyErr_Occurred()) SWIG_fail;
53509 }
53510 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53511 return resultobj;
53512 fail:
53513 return NULL;
53514 }
53515
53516
53517 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53518 PyObject *resultobj = 0;
53519 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53520 wxGBSpan result;
53521 void *argp1 = 0 ;
53522 int res1 = 0 ;
53523 PyObject *swig_obj[1] ;
53524
53525 if (!args) SWIG_fail;
53526 swig_obj[0] = args;
53527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53528 if (!SWIG_IsOK(res1)) {
53529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53530 }
53531 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53532 {
53533 PyThreadState* __tstate = wxPyBeginAllowThreads();
53534 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53535 wxPyEndAllowThreads(__tstate);
53536 if (PyErr_Occurred()) SWIG_fail;
53537 }
53538 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53539 return resultobj;
53540 fail:
53541 return NULL;
53542 }
53543
53544
53545 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53546 PyObject *resultobj = 0;
53547 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53548 wxGBPosition *arg2 = 0 ;
53549 bool result;
53550 void *argp1 = 0 ;
53551 int res1 = 0 ;
53552 wxGBPosition temp2 ;
53553 PyObject * obj0 = 0 ;
53554 PyObject * obj1 = 0 ;
53555 char * kwnames[] = {
53556 (char *) "self",(char *) "pos", NULL
53557 };
53558
53559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53561 if (!SWIG_IsOK(res1)) {
53562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53563 }
53564 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53565 {
53566 arg2 = &temp2;
53567 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53568 }
53569 {
53570 PyThreadState* __tstate = wxPyBeginAllowThreads();
53571 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53572 wxPyEndAllowThreads(__tstate);
53573 if (PyErr_Occurred()) SWIG_fail;
53574 }
53575 {
53576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53577 }
53578 return resultobj;
53579 fail:
53580 return NULL;
53581 }
53582
53583
53584 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53585 PyObject *resultobj = 0;
53586 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53587 wxGBSpan *arg2 = 0 ;
53588 bool result;
53589 void *argp1 = 0 ;
53590 int res1 = 0 ;
53591 wxGBSpan temp2 ;
53592 PyObject * obj0 = 0 ;
53593 PyObject * obj1 = 0 ;
53594 char * kwnames[] = {
53595 (char *) "self",(char *) "span", NULL
53596 };
53597
53598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53600 if (!SWIG_IsOK(res1)) {
53601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53602 }
53603 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53604 {
53605 arg2 = &temp2;
53606 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53607 }
53608 {
53609 PyThreadState* __tstate = wxPyBeginAllowThreads();
53610 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53611 wxPyEndAllowThreads(__tstate);
53612 if (PyErr_Occurred()) SWIG_fail;
53613 }
53614 {
53615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53616 }
53617 return resultobj;
53618 fail:
53619 return NULL;
53620 }
53621
53622
53623 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53624 PyObject *resultobj = 0;
53625 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53626 wxGBSizerItem *arg2 = 0 ;
53627 bool result;
53628 void *argp1 = 0 ;
53629 int res1 = 0 ;
53630 void *argp2 = 0 ;
53631 int res2 = 0 ;
53632 PyObject * obj0 = 0 ;
53633 PyObject * obj1 = 0 ;
53634 char * kwnames[] = {
53635 (char *) "self",(char *) "other", NULL
53636 };
53637
53638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53640 if (!SWIG_IsOK(res1)) {
53641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53642 }
53643 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53644 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53645 if (!SWIG_IsOK(res2)) {
53646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53647 }
53648 if (!argp2) {
53649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53650 }
53651 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53652 {
53653 PyThreadState* __tstate = wxPyBeginAllowThreads();
53654 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53655 wxPyEndAllowThreads(__tstate);
53656 if (PyErr_Occurred()) SWIG_fail;
53657 }
53658 {
53659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53660 }
53661 return resultobj;
53662 fail:
53663 return NULL;
53664 }
53665
53666
53667 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53668 PyObject *resultobj = 0;
53669 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53670 wxGBPosition *arg2 = 0 ;
53671 wxGBSpan *arg3 = 0 ;
53672 bool result;
53673 void *argp1 = 0 ;
53674 int res1 = 0 ;
53675 wxGBPosition temp2 ;
53676 wxGBSpan temp3 ;
53677 PyObject * obj0 = 0 ;
53678 PyObject * obj1 = 0 ;
53679 PyObject * obj2 = 0 ;
53680 char * kwnames[] = {
53681 (char *) "self",(char *) "pos",(char *) "span", NULL
53682 };
53683
53684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53686 if (!SWIG_IsOK(res1)) {
53687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53688 }
53689 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53690 {
53691 arg2 = &temp2;
53692 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53693 }
53694 {
53695 arg3 = &temp3;
53696 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53697 }
53698 {
53699 PyThreadState* __tstate = wxPyBeginAllowThreads();
53700 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53701 wxPyEndAllowThreads(__tstate);
53702 if (PyErr_Occurred()) SWIG_fail;
53703 }
53704 {
53705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53706 }
53707 return resultobj;
53708 fail:
53709 return NULL;
53710 }
53711
53712
53713 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53714 PyObject *resultobj = 0;
53715 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53716 wxGBPosition result;
53717 void *argp1 = 0 ;
53718 int res1 = 0 ;
53719 PyObject *swig_obj[1] ;
53720
53721 if (!args) SWIG_fail;
53722 swig_obj[0] = args;
53723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53724 if (!SWIG_IsOK(res1)) {
53725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53726 }
53727 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53728 {
53729 PyThreadState* __tstate = wxPyBeginAllowThreads();
53730 result = wxGBSizerItem_GetEndPos(arg1);
53731 wxPyEndAllowThreads(__tstate);
53732 if (PyErr_Occurred()) SWIG_fail;
53733 }
53734 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53735 return resultobj;
53736 fail:
53737 return NULL;
53738 }
53739
53740
53741 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53742 PyObject *resultobj = 0;
53743 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53744 wxGridBagSizer *result = 0 ;
53745 void *argp1 = 0 ;
53746 int res1 = 0 ;
53747 PyObject *swig_obj[1] ;
53748
53749 if (!args) SWIG_fail;
53750 swig_obj[0] = args;
53751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53752 if (!SWIG_IsOK(res1)) {
53753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53754 }
53755 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53756 {
53757 PyThreadState* __tstate = wxPyBeginAllowThreads();
53758 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53759 wxPyEndAllowThreads(__tstate);
53760 if (PyErr_Occurred()) SWIG_fail;
53761 }
53762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53763 return resultobj;
53764 fail:
53765 return NULL;
53766 }
53767
53768
53769 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53770 PyObject *resultobj = 0;
53771 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53772 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53773 void *argp1 = 0 ;
53774 int res1 = 0 ;
53775 void *argp2 = 0 ;
53776 int res2 = 0 ;
53777 PyObject * obj0 = 0 ;
53778 PyObject * obj1 = 0 ;
53779 char * kwnames[] = {
53780 (char *) "self",(char *) "sizer", NULL
53781 };
53782
53783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53785 if (!SWIG_IsOK(res1)) {
53786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53787 }
53788 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53790 if (!SWIG_IsOK(res2)) {
53791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53792 }
53793 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53794 {
53795 PyThreadState* __tstate = wxPyBeginAllowThreads();
53796 (arg1)->SetGBSizer(arg2);
53797 wxPyEndAllowThreads(__tstate);
53798 if (PyErr_Occurred()) SWIG_fail;
53799 }
53800 resultobj = SWIG_Py_Void();
53801 return resultobj;
53802 fail:
53803 return NULL;
53804 }
53805
53806
53807 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53808 PyObject *obj;
53809 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53810 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53811 return SWIG_Py_Void();
53812 }
53813
53814 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53815 return SWIG_Python_InitShadowInstance(args);
53816 }
53817
53818 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53819 PyObject *resultobj = 0;
53820 int arg1 = (int) 0 ;
53821 int arg2 = (int) 0 ;
53822 wxGridBagSizer *result = 0 ;
53823 int val1 ;
53824 int ecode1 = 0 ;
53825 int val2 ;
53826 int ecode2 = 0 ;
53827 PyObject * obj0 = 0 ;
53828 PyObject * obj1 = 0 ;
53829 char * kwnames[] = {
53830 (char *) "vgap",(char *) "hgap", NULL
53831 };
53832
53833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53834 if (obj0) {
53835 ecode1 = SWIG_AsVal_int(obj0, &val1);
53836 if (!SWIG_IsOK(ecode1)) {
53837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53838 }
53839 arg1 = static_cast< int >(val1);
53840 }
53841 if (obj1) {
53842 ecode2 = SWIG_AsVal_int(obj1, &val2);
53843 if (!SWIG_IsOK(ecode2)) {
53844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53845 }
53846 arg2 = static_cast< int >(val2);
53847 }
53848 {
53849 PyThreadState* __tstate = wxPyBeginAllowThreads();
53850 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53851 wxPyEndAllowThreads(__tstate);
53852 if (PyErr_Occurred()) SWIG_fail;
53853 }
53854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53855 return resultobj;
53856 fail:
53857 return NULL;
53858 }
53859
53860
53861 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53862 PyObject *resultobj = 0;
53863 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53864 PyObject *arg2 = (PyObject *) 0 ;
53865 wxGBPosition *arg3 = 0 ;
53866 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53867 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53868 int arg5 = (int) 0 ;
53869 int arg6 = (int) 0 ;
53870 PyObject *arg7 = (PyObject *) NULL ;
53871 wxGBSizerItem *result = 0 ;
53872 void *argp1 = 0 ;
53873 int res1 = 0 ;
53874 wxGBPosition temp3 ;
53875 wxGBSpan temp4 ;
53876 int val5 ;
53877 int ecode5 = 0 ;
53878 int val6 ;
53879 int ecode6 = 0 ;
53880 PyObject * obj0 = 0 ;
53881 PyObject * obj1 = 0 ;
53882 PyObject * obj2 = 0 ;
53883 PyObject * obj3 = 0 ;
53884 PyObject * obj4 = 0 ;
53885 PyObject * obj5 = 0 ;
53886 PyObject * obj6 = 0 ;
53887 char * kwnames[] = {
53888 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53889 };
53890
53891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53893 if (!SWIG_IsOK(res1)) {
53894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53895 }
53896 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53897 arg2 = obj1;
53898 {
53899 arg3 = &temp3;
53900 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53901 }
53902 if (obj3) {
53903 {
53904 arg4 = &temp4;
53905 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53906 }
53907 }
53908 if (obj4) {
53909 ecode5 = SWIG_AsVal_int(obj4, &val5);
53910 if (!SWIG_IsOK(ecode5)) {
53911 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53912 }
53913 arg5 = static_cast< int >(val5);
53914 }
53915 if (obj5) {
53916 ecode6 = SWIG_AsVal_int(obj5, &val6);
53917 if (!SWIG_IsOK(ecode6)) {
53918 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53919 }
53920 arg6 = static_cast< int >(val6);
53921 }
53922 if (obj6) {
53923 arg7 = obj6;
53924 }
53925 {
53926 PyThreadState* __tstate = wxPyBeginAllowThreads();
53927 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53928 wxPyEndAllowThreads(__tstate);
53929 if (PyErr_Occurred()) SWIG_fail;
53930 }
53931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53932 return resultobj;
53933 fail:
53934 return NULL;
53935 }
53936
53937
53938 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53939 PyObject *resultobj = 0;
53940 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53941 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53942 wxGBSizerItem *result = 0 ;
53943 void *argp1 = 0 ;
53944 int res1 = 0 ;
53945 int res2 = 0 ;
53946 PyObject * obj0 = 0 ;
53947 PyObject * obj1 = 0 ;
53948 char * kwnames[] = {
53949 (char *) "self",(char *) "item", NULL
53950 };
53951
53952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53954 if (!SWIG_IsOK(res1)) {
53955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53956 }
53957 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53958 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53959 if (!SWIG_IsOK(res2)) {
53960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
53961 }
53962 {
53963 PyThreadState* __tstate = wxPyBeginAllowThreads();
53964 result = (wxGBSizerItem *)(arg1)->Add(arg2);
53965 wxPyEndAllowThreads(__tstate);
53966 if (PyErr_Occurred()) SWIG_fail;
53967 }
53968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53969 return resultobj;
53970 fail:
53971 return NULL;
53972 }
53973
53974
53975 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53976 PyObject *resultobj = 0;
53977 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53978 int arg2 ;
53979 int arg3 ;
53980 wxSize result;
53981 void *argp1 = 0 ;
53982 int res1 = 0 ;
53983 int val2 ;
53984 int ecode2 = 0 ;
53985 int val3 ;
53986 int ecode3 = 0 ;
53987 PyObject * obj0 = 0 ;
53988 PyObject * obj1 = 0 ;
53989 PyObject * obj2 = 0 ;
53990 char * kwnames[] = {
53991 (char *) "self",(char *) "row",(char *) "col", NULL
53992 };
53993
53994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53996 if (!SWIG_IsOK(res1)) {
53997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
53998 }
53999 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54000 ecode2 = SWIG_AsVal_int(obj1, &val2);
54001 if (!SWIG_IsOK(ecode2)) {
54002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54003 }
54004 arg2 = static_cast< int >(val2);
54005 ecode3 = SWIG_AsVal_int(obj2, &val3);
54006 if (!SWIG_IsOK(ecode3)) {
54007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54008 }
54009 arg3 = static_cast< int >(val3);
54010 {
54011 PyThreadState* __tstate = wxPyBeginAllowThreads();
54012 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54013 wxPyEndAllowThreads(__tstate);
54014 if (PyErr_Occurred()) SWIG_fail;
54015 }
54016 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54017 return resultobj;
54018 fail:
54019 return NULL;
54020 }
54021
54022
54023 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54024 PyObject *resultobj = 0;
54025 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54026 wxSize result;
54027 void *argp1 = 0 ;
54028 int res1 = 0 ;
54029 PyObject *swig_obj[1] ;
54030
54031 if (!args) SWIG_fail;
54032 swig_obj[0] = args;
54033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54034 if (!SWIG_IsOK(res1)) {
54035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54036 }
54037 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54038 {
54039 PyThreadState* __tstate = wxPyBeginAllowThreads();
54040 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54041 wxPyEndAllowThreads(__tstate);
54042 if (PyErr_Occurred()) SWIG_fail;
54043 }
54044 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54045 return resultobj;
54046 fail:
54047 return NULL;
54048 }
54049
54050
54051 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54052 PyObject *resultobj = 0;
54053 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54054 wxSize *arg2 = 0 ;
54055 void *argp1 = 0 ;
54056 int res1 = 0 ;
54057 wxSize temp2 ;
54058 PyObject * obj0 = 0 ;
54059 PyObject * obj1 = 0 ;
54060 char * kwnames[] = {
54061 (char *) "self",(char *) "sz", NULL
54062 };
54063
54064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54066 if (!SWIG_IsOK(res1)) {
54067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54068 }
54069 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54070 {
54071 arg2 = &temp2;
54072 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54073 }
54074 {
54075 PyThreadState* __tstate = wxPyBeginAllowThreads();
54076 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54077 wxPyEndAllowThreads(__tstate);
54078 if (PyErr_Occurred()) SWIG_fail;
54079 }
54080 resultobj = SWIG_Py_Void();
54081 return resultobj;
54082 fail:
54083 return NULL;
54084 }
54085
54086
54087 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54088 PyObject *resultobj = 0;
54089 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54090 wxWindow *arg2 = (wxWindow *) 0 ;
54091 wxGBPosition result;
54092 void *argp1 = 0 ;
54093 int res1 = 0 ;
54094 void *argp2 = 0 ;
54095 int res2 = 0 ;
54096
54097 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54099 if (!SWIG_IsOK(res1)) {
54100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54101 }
54102 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54103 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54104 if (!SWIG_IsOK(res2)) {
54105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54106 }
54107 arg2 = reinterpret_cast< wxWindow * >(argp2);
54108 {
54109 PyThreadState* __tstate = wxPyBeginAllowThreads();
54110 result = (arg1)->GetItemPosition(arg2);
54111 wxPyEndAllowThreads(__tstate);
54112 if (PyErr_Occurred()) SWIG_fail;
54113 }
54114 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54115 return resultobj;
54116 fail:
54117 return NULL;
54118 }
54119
54120
54121 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54122 PyObject *resultobj = 0;
54123 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54124 wxSizer *arg2 = (wxSizer *) 0 ;
54125 wxGBPosition result;
54126 void *argp1 = 0 ;
54127 int res1 = 0 ;
54128 void *argp2 = 0 ;
54129 int res2 = 0 ;
54130
54131 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54133 if (!SWIG_IsOK(res1)) {
54134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54135 }
54136 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54137 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54138 if (!SWIG_IsOK(res2)) {
54139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54140 }
54141 arg2 = reinterpret_cast< wxSizer * >(argp2);
54142 {
54143 PyThreadState* __tstate = wxPyBeginAllowThreads();
54144 result = (arg1)->GetItemPosition(arg2);
54145 wxPyEndAllowThreads(__tstate);
54146 if (PyErr_Occurred()) SWIG_fail;
54147 }
54148 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54149 return resultobj;
54150 fail:
54151 return NULL;
54152 }
54153
54154
54155 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54156 PyObject *resultobj = 0;
54157 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54158 size_t arg2 ;
54159 wxGBPosition result;
54160 void *argp1 = 0 ;
54161 int res1 = 0 ;
54162 size_t val2 ;
54163 int ecode2 = 0 ;
54164
54165 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54167 if (!SWIG_IsOK(res1)) {
54168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54169 }
54170 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54171 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54172 if (!SWIG_IsOK(ecode2)) {
54173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54174 }
54175 arg2 = static_cast< size_t >(val2);
54176 {
54177 PyThreadState* __tstate = wxPyBeginAllowThreads();
54178 result = (arg1)->GetItemPosition(arg2);
54179 wxPyEndAllowThreads(__tstate);
54180 if (PyErr_Occurred()) SWIG_fail;
54181 }
54182 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54183 return resultobj;
54184 fail:
54185 return NULL;
54186 }
54187
54188
54189 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54190 int argc;
54191 PyObject *argv[3];
54192
54193 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54194 --argc;
54195 if (argc == 2) {
54196 int _v = 0;
54197 {
54198 void *vptr = 0;
54199 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54200 _v = SWIG_CheckState(res);
54201 }
54202 if (!_v) goto check_1;
54203 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54204 }
54205 check_1:
54206
54207 if (argc == 2) {
54208 int _v = 0;
54209 {
54210 void *vptr = 0;
54211 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54212 _v = SWIG_CheckState(res);
54213 }
54214 if (!_v) goto check_2;
54215 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54216 }
54217 check_2:
54218
54219 if (argc == 2) {
54220 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54221 }
54222
54223 fail:
54224 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54225 return NULL;
54226 }
54227
54228
54229 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54230 PyObject *resultobj = 0;
54231 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54232 wxWindow *arg2 = (wxWindow *) 0 ;
54233 wxGBPosition *arg3 = 0 ;
54234 bool result;
54235 void *argp1 = 0 ;
54236 int res1 = 0 ;
54237 void *argp2 = 0 ;
54238 int res2 = 0 ;
54239 wxGBPosition temp3 ;
54240
54241 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54243 if (!SWIG_IsOK(res1)) {
54244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54245 }
54246 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54247 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54248 if (!SWIG_IsOK(res2)) {
54249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54250 }
54251 arg2 = reinterpret_cast< wxWindow * >(argp2);
54252 {
54253 arg3 = &temp3;
54254 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54255 }
54256 {
54257 PyThreadState* __tstate = wxPyBeginAllowThreads();
54258 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54259 wxPyEndAllowThreads(__tstate);
54260 if (PyErr_Occurred()) SWIG_fail;
54261 }
54262 {
54263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54264 }
54265 return resultobj;
54266 fail:
54267 return NULL;
54268 }
54269
54270
54271 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54272 PyObject *resultobj = 0;
54273 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54274 wxSizer *arg2 = (wxSizer *) 0 ;
54275 wxGBPosition *arg3 = 0 ;
54276 bool result;
54277 void *argp1 = 0 ;
54278 int res1 = 0 ;
54279 void *argp2 = 0 ;
54280 int res2 = 0 ;
54281 wxGBPosition temp3 ;
54282
54283 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54285 if (!SWIG_IsOK(res1)) {
54286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54287 }
54288 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54289 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54290 if (!SWIG_IsOK(res2)) {
54291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54292 }
54293 arg2 = reinterpret_cast< wxSizer * >(argp2);
54294 {
54295 arg3 = &temp3;
54296 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54297 }
54298 {
54299 PyThreadState* __tstate = wxPyBeginAllowThreads();
54300 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54301 wxPyEndAllowThreads(__tstate);
54302 if (PyErr_Occurred()) SWIG_fail;
54303 }
54304 {
54305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54306 }
54307 return resultobj;
54308 fail:
54309 return NULL;
54310 }
54311
54312
54313 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54314 PyObject *resultobj = 0;
54315 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54316 size_t arg2 ;
54317 wxGBPosition *arg3 = 0 ;
54318 bool result;
54319 void *argp1 = 0 ;
54320 int res1 = 0 ;
54321 size_t val2 ;
54322 int ecode2 = 0 ;
54323 wxGBPosition temp3 ;
54324
54325 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54327 if (!SWIG_IsOK(res1)) {
54328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54329 }
54330 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54331 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54332 if (!SWIG_IsOK(ecode2)) {
54333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54334 }
54335 arg2 = static_cast< size_t >(val2);
54336 {
54337 arg3 = &temp3;
54338 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54339 }
54340 {
54341 PyThreadState* __tstate = wxPyBeginAllowThreads();
54342 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54343 wxPyEndAllowThreads(__tstate);
54344 if (PyErr_Occurred()) SWIG_fail;
54345 }
54346 {
54347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54348 }
54349 return resultobj;
54350 fail:
54351 return NULL;
54352 }
54353
54354
54355 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54356 int argc;
54357 PyObject *argv[4];
54358
54359 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54360 --argc;
54361 if (argc == 3) {
54362 int _v = 0;
54363 {
54364 void *vptr = 0;
54365 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54366 _v = SWIG_CheckState(res);
54367 }
54368 if (!_v) goto check_1;
54369 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54370 }
54371 check_1:
54372
54373 if (argc == 3) {
54374 int _v = 0;
54375 {
54376 void *vptr = 0;
54377 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54378 _v = SWIG_CheckState(res);
54379 }
54380 if (!_v) goto check_2;
54381 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54382 }
54383 check_2:
54384
54385 if (argc == 3) {
54386 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54387 }
54388
54389 fail:
54390 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54391 return NULL;
54392 }
54393
54394
54395 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54396 PyObject *resultobj = 0;
54397 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54398 wxWindow *arg2 = (wxWindow *) 0 ;
54399 wxGBSpan result;
54400 void *argp1 = 0 ;
54401 int res1 = 0 ;
54402 void *argp2 = 0 ;
54403 int res2 = 0 ;
54404
54405 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54407 if (!SWIG_IsOK(res1)) {
54408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54409 }
54410 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54411 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54412 if (!SWIG_IsOK(res2)) {
54413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54414 }
54415 arg2 = reinterpret_cast< wxWindow * >(argp2);
54416 {
54417 PyThreadState* __tstate = wxPyBeginAllowThreads();
54418 result = (arg1)->GetItemSpan(arg2);
54419 wxPyEndAllowThreads(__tstate);
54420 if (PyErr_Occurred()) SWIG_fail;
54421 }
54422 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54423 return resultobj;
54424 fail:
54425 return NULL;
54426 }
54427
54428
54429 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54430 PyObject *resultobj = 0;
54431 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54432 wxSizer *arg2 = (wxSizer *) 0 ;
54433 wxGBSpan result;
54434 void *argp1 = 0 ;
54435 int res1 = 0 ;
54436 void *argp2 = 0 ;
54437 int res2 = 0 ;
54438
54439 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54441 if (!SWIG_IsOK(res1)) {
54442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54443 }
54444 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54445 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54446 if (!SWIG_IsOK(res2)) {
54447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54448 }
54449 arg2 = reinterpret_cast< wxSizer * >(argp2);
54450 {
54451 PyThreadState* __tstate = wxPyBeginAllowThreads();
54452 result = (arg1)->GetItemSpan(arg2);
54453 wxPyEndAllowThreads(__tstate);
54454 if (PyErr_Occurred()) SWIG_fail;
54455 }
54456 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54457 return resultobj;
54458 fail:
54459 return NULL;
54460 }
54461
54462
54463 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54464 PyObject *resultobj = 0;
54465 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54466 size_t arg2 ;
54467 wxGBSpan result;
54468 void *argp1 = 0 ;
54469 int res1 = 0 ;
54470 size_t val2 ;
54471 int ecode2 = 0 ;
54472
54473 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54475 if (!SWIG_IsOK(res1)) {
54476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54477 }
54478 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54479 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54480 if (!SWIG_IsOK(ecode2)) {
54481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54482 }
54483 arg2 = static_cast< size_t >(val2);
54484 {
54485 PyThreadState* __tstate = wxPyBeginAllowThreads();
54486 result = (arg1)->GetItemSpan(arg2);
54487 wxPyEndAllowThreads(__tstate);
54488 if (PyErr_Occurred()) SWIG_fail;
54489 }
54490 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54491 return resultobj;
54492 fail:
54493 return NULL;
54494 }
54495
54496
54497 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54498 int argc;
54499 PyObject *argv[3];
54500
54501 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54502 --argc;
54503 if (argc == 2) {
54504 int _v = 0;
54505 {
54506 void *vptr = 0;
54507 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54508 _v = SWIG_CheckState(res);
54509 }
54510 if (!_v) goto check_1;
54511 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54512 }
54513 check_1:
54514
54515 if (argc == 2) {
54516 int _v = 0;
54517 {
54518 void *vptr = 0;
54519 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54520 _v = SWIG_CheckState(res);
54521 }
54522 if (!_v) goto check_2;
54523 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54524 }
54525 check_2:
54526
54527 if (argc == 2) {
54528 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54529 }
54530
54531 fail:
54532 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54533 return NULL;
54534 }
54535
54536
54537 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54538 PyObject *resultobj = 0;
54539 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54540 wxWindow *arg2 = (wxWindow *) 0 ;
54541 wxGBSpan *arg3 = 0 ;
54542 bool result;
54543 void *argp1 = 0 ;
54544 int res1 = 0 ;
54545 void *argp2 = 0 ;
54546 int res2 = 0 ;
54547 wxGBSpan temp3 ;
54548
54549 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54551 if (!SWIG_IsOK(res1)) {
54552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54553 }
54554 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54555 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54556 if (!SWIG_IsOK(res2)) {
54557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54558 }
54559 arg2 = reinterpret_cast< wxWindow * >(argp2);
54560 {
54561 arg3 = &temp3;
54562 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54563 }
54564 {
54565 PyThreadState* __tstate = wxPyBeginAllowThreads();
54566 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54567 wxPyEndAllowThreads(__tstate);
54568 if (PyErr_Occurred()) SWIG_fail;
54569 }
54570 {
54571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54572 }
54573 return resultobj;
54574 fail:
54575 return NULL;
54576 }
54577
54578
54579 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54580 PyObject *resultobj = 0;
54581 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54582 wxSizer *arg2 = (wxSizer *) 0 ;
54583 wxGBSpan *arg3 = 0 ;
54584 bool result;
54585 void *argp1 = 0 ;
54586 int res1 = 0 ;
54587 void *argp2 = 0 ;
54588 int res2 = 0 ;
54589 wxGBSpan temp3 ;
54590
54591 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54593 if (!SWIG_IsOK(res1)) {
54594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54595 }
54596 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54597 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54598 if (!SWIG_IsOK(res2)) {
54599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54600 }
54601 arg2 = reinterpret_cast< wxSizer * >(argp2);
54602 {
54603 arg3 = &temp3;
54604 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54605 }
54606 {
54607 PyThreadState* __tstate = wxPyBeginAllowThreads();
54608 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54609 wxPyEndAllowThreads(__tstate);
54610 if (PyErr_Occurred()) SWIG_fail;
54611 }
54612 {
54613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54614 }
54615 return resultobj;
54616 fail:
54617 return NULL;
54618 }
54619
54620
54621 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54622 PyObject *resultobj = 0;
54623 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54624 size_t arg2 ;
54625 wxGBSpan *arg3 = 0 ;
54626 bool result;
54627 void *argp1 = 0 ;
54628 int res1 = 0 ;
54629 size_t val2 ;
54630 int ecode2 = 0 ;
54631 wxGBSpan temp3 ;
54632
54633 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54635 if (!SWIG_IsOK(res1)) {
54636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54637 }
54638 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54639 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54640 if (!SWIG_IsOK(ecode2)) {
54641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54642 }
54643 arg2 = static_cast< size_t >(val2);
54644 {
54645 arg3 = &temp3;
54646 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54647 }
54648 {
54649 PyThreadState* __tstate = wxPyBeginAllowThreads();
54650 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54651 wxPyEndAllowThreads(__tstate);
54652 if (PyErr_Occurred()) SWIG_fail;
54653 }
54654 {
54655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54656 }
54657 return resultobj;
54658 fail:
54659 return NULL;
54660 }
54661
54662
54663 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54664 int argc;
54665 PyObject *argv[4];
54666
54667 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54668 --argc;
54669 if (argc == 3) {
54670 int _v = 0;
54671 {
54672 void *vptr = 0;
54673 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54674 _v = SWIG_CheckState(res);
54675 }
54676 if (!_v) goto check_1;
54677 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54678 }
54679 check_1:
54680
54681 if (argc == 3) {
54682 int _v = 0;
54683 {
54684 void *vptr = 0;
54685 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54686 _v = SWIG_CheckState(res);
54687 }
54688 if (!_v) goto check_2;
54689 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54690 }
54691 check_2:
54692
54693 if (argc == 3) {
54694 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54695 }
54696
54697 fail:
54698 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54699 return NULL;
54700 }
54701
54702
54703 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54704 PyObject *resultobj = 0;
54705 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54706 wxWindow *arg2 = (wxWindow *) 0 ;
54707 wxGBSizerItem *result = 0 ;
54708 void *argp1 = 0 ;
54709 int res1 = 0 ;
54710 void *argp2 = 0 ;
54711 int res2 = 0 ;
54712
54713 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54715 if (!SWIG_IsOK(res1)) {
54716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54717 }
54718 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54719 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54720 if (!SWIG_IsOK(res2)) {
54721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54722 }
54723 arg2 = reinterpret_cast< wxWindow * >(argp2);
54724 {
54725 PyThreadState* __tstate = wxPyBeginAllowThreads();
54726 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54727 wxPyEndAllowThreads(__tstate);
54728 if (PyErr_Occurred()) SWIG_fail;
54729 }
54730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54731 return resultobj;
54732 fail:
54733 return NULL;
54734 }
54735
54736
54737 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54738 PyObject *resultobj = 0;
54739 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54740 wxSizer *arg2 = (wxSizer *) 0 ;
54741 wxGBSizerItem *result = 0 ;
54742 void *argp1 = 0 ;
54743 int res1 = 0 ;
54744 void *argp2 = 0 ;
54745 int res2 = 0 ;
54746
54747 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54749 if (!SWIG_IsOK(res1)) {
54750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54751 }
54752 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54753 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54754 if (!SWIG_IsOK(res2)) {
54755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54756 }
54757 arg2 = reinterpret_cast< wxSizer * >(argp2);
54758 {
54759 PyThreadState* __tstate = wxPyBeginAllowThreads();
54760 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54761 wxPyEndAllowThreads(__tstate);
54762 if (PyErr_Occurred()) SWIG_fail;
54763 }
54764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54765 return resultobj;
54766 fail:
54767 return NULL;
54768 }
54769
54770
54771 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54772 int argc;
54773 PyObject *argv[3];
54774
54775 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54776 --argc;
54777 if (argc == 2) {
54778 int _v = 0;
54779 {
54780 void *vptr = 0;
54781 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54782 _v = SWIG_CheckState(res);
54783 }
54784 if (!_v) goto check_1;
54785 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54786 }
54787 check_1:
54788
54789 if (argc == 2) {
54790 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54791 }
54792
54793 fail:
54794 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54795 return NULL;
54796 }
54797
54798
54799 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54800 PyObject *resultobj = 0;
54801 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54802 wxGBPosition *arg2 = 0 ;
54803 wxGBSizerItem *result = 0 ;
54804 void *argp1 = 0 ;
54805 int res1 = 0 ;
54806 wxGBPosition temp2 ;
54807 PyObject * obj0 = 0 ;
54808 PyObject * obj1 = 0 ;
54809 char * kwnames[] = {
54810 (char *) "self",(char *) "pos", NULL
54811 };
54812
54813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54815 if (!SWIG_IsOK(res1)) {
54816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54817 }
54818 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54819 {
54820 arg2 = &temp2;
54821 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54822 }
54823 {
54824 PyThreadState* __tstate = wxPyBeginAllowThreads();
54825 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54826 wxPyEndAllowThreads(__tstate);
54827 if (PyErr_Occurred()) SWIG_fail;
54828 }
54829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54830 return resultobj;
54831 fail:
54832 return NULL;
54833 }
54834
54835
54836 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54837 PyObject *resultobj = 0;
54838 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54839 wxPoint *arg2 = 0 ;
54840 wxGBSizerItem *result = 0 ;
54841 void *argp1 = 0 ;
54842 int res1 = 0 ;
54843 wxPoint temp2 ;
54844 PyObject * obj0 = 0 ;
54845 PyObject * obj1 = 0 ;
54846 char * kwnames[] = {
54847 (char *) "self",(char *) "pt", NULL
54848 };
54849
54850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54852 if (!SWIG_IsOK(res1)) {
54853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54854 }
54855 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54856 {
54857 arg2 = &temp2;
54858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54859 }
54860 {
54861 PyThreadState* __tstate = wxPyBeginAllowThreads();
54862 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54863 wxPyEndAllowThreads(__tstate);
54864 if (PyErr_Occurred()) SWIG_fail;
54865 }
54866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54867 return resultobj;
54868 fail:
54869 return NULL;
54870 }
54871
54872
54873 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54874 PyObject *resultobj = 0;
54875 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54876 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54877 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54878 bool result;
54879 void *argp1 = 0 ;
54880 int res1 = 0 ;
54881 void *argp2 = 0 ;
54882 int res2 = 0 ;
54883 void *argp3 = 0 ;
54884 int res3 = 0 ;
54885 PyObject * obj0 = 0 ;
54886 PyObject * obj1 = 0 ;
54887 PyObject * obj2 = 0 ;
54888 char * kwnames[] = {
54889 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54890 };
54891
54892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54894 if (!SWIG_IsOK(res1)) {
54895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54896 }
54897 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54898 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54899 if (!SWIG_IsOK(res2)) {
54900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54901 }
54902 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54903 if (obj2) {
54904 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54905 if (!SWIG_IsOK(res3)) {
54906 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54907 }
54908 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54909 }
54910 {
54911 PyThreadState* __tstate = wxPyBeginAllowThreads();
54912 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54913 wxPyEndAllowThreads(__tstate);
54914 if (PyErr_Occurred()) SWIG_fail;
54915 }
54916 {
54917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54918 }
54919 return resultobj;
54920 fail:
54921 return NULL;
54922 }
54923
54924
54925 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54926 PyObject *resultobj = 0;
54927 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54928 wxGBPosition *arg2 = 0 ;
54929 wxGBSpan *arg3 = 0 ;
54930 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54931 bool result;
54932 void *argp1 = 0 ;
54933 int res1 = 0 ;
54934 wxGBPosition temp2 ;
54935 wxGBSpan temp3 ;
54936 void *argp4 = 0 ;
54937 int res4 = 0 ;
54938 PyObject * obj0 = 0 ;
54939 PyObject * obj1 = 0 ;
54940 PyObject * obj2 = 0 ;
54941 PyObject * obj3 = 0 ;
54942 char * kwnames[] = {
54943 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54944 };
54945
54946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54948 if (!SWIG_IsOK(res1)) {
54949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54950 }
54951 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54952 {
54953 arg2 = &temp2;
54954 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54955 }
54956 {
54957 arg3 = &temp3;
54958 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54959 }
54960 if (obj3) {
54961 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54962 if (!SWIG_IsOK(res4)) {
54963 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
54964 }
54965 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
54966 }
54967 {
54968 PyThreadState* __tstate = wxPyBeginAllowThreads();
54969 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
54970 wxPyEndAllowThreads(__tstate);
54971 if (PyErr_Occurred()) SWIG_fail;
54972 }
54973 {
54974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54975 }
54976 return resultobj;
54977 fail:
54978 return NULL;
54979 }
54980
54981
54982 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54983 PyObject *obj;
54984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54985 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
54986 return SWIG_Py_Void();
54987 }
54988
54989 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54990 return SWIG_Python_InitShadowInstance(args);
54991 }
54992
54993 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54994 PyObject *resultobj = 0;
54995 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
54996 wxRelationship arg2 ;
54997 wxWindow *arg3 = (wxWindow *) 0 ;
54998 wxEdge arg4 ;
54999 int arg5 = (int) 0 ;
55000 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55001 void *argp1 = 0 ;
55002 int res1 = 0 ;
55003 int val2 ;
55004 int ecode2 = 0 ;
55005 void *argp3 = 0 ;
55006 int res3 = 0 ;
55007 int val4 ;
55008 int ecode4 = 0 ;
55009 int val5 ;
55010 int ecode5 = 0 ;
55011 int val6 ;
55012 int ecode6 = 0 ;
55013 PyObject * obj0 = 0 ;
55014 PyObject * obj1 = 0 ;
55015 PyObject * obj2 = 0 ;
55016 PyObject * obj3 = 0 ;
55017 PyObject * obj4 = 0 ;
55018 PyObject * obj5 = 0 ;
55019 char * kwnames[] = {
55020 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55021 };
55022
55023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55025 if (!SWIG_IsOK(res1)) {
55026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55027 }
55028 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55029 ecode2 = SWIG_AsVal_int(obj1, &val2);
55030 if (!SWIG_IsOK(ecode2)) {
55031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55032 }
55033 arg2 = static_cast< wxRelationship >(val2);
55034 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55035 if (!SWIG_IsOK(res3)) {
55036 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55037 }
55038 arg3 = reinterpret_cast< wxWindow * >(argp3);
55039 ecode4 = SWIG_AsVal_int(obj3, &val4);
55040 if (!SWIG_IsOK(ecode4)) {
55041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55042 }
55043 arg4 = static_cast< wxEdge >(val4);
55044 if (obj4) {
55045 ecode5 = SWIG_AsVal_int(obj4, &val5);
55046 if (!SWIG_IsOK(ecode5)) {
55047 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55048 }
55049 arg5 = static_cast< int >(val5);
55050 }
55051 if (obj5) {
55052 ecode6 = SWIG_AsVal_int(obj5, &val6);
55053 if (!SWIG_IsOK(ecode6)) {
55054 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55055 }
55056 arg6 = static_cast< int >(val6);
55057 }
55058 {
55059 PyThreadState* __tstate = wxPyBeginAllowThreads();
55060 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55061 wxPyEndAllowThreads(__tstate);
55062 if (PyErr_Occurred()) SWIG_fail;
55063 }
55064 resultobj = SWIG_Py_Void();
55065 return resultobj;
55066 fail:
55067 return NULL;
55068 }
55069
55070
55071 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55072 PyObject *resultobj = 0;
55073 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55074 wxWindow *arg2 = (wxWindow *) 0 ;
55075 int arg3 = (int) 0 ;
55076 void *argp1 = 0 ;
55077 int res1 = 0 ;
55078 void *argp2 = 0 ;
55079 int res2 = 0 ;
55080 int val3 ;
55081 int ecode3 = 0 ;
55082 PyObject * obj0 = 0 ;
55083 PyObject * obj1 = 0 ;
55084 PyObject * obj2 = 0 ;
55085 char * kwnames[] = {
55086 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55087 };
55088
55089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55091 if (!SWIG_IsOK(res1)) {
55092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55093 }
55094 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55095 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55096 if (!SWIG_IsOK(res2)) {
55097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55098 }
55099 arg2 = reinterpret_cast< wxWindow * >(argp2);
55100 if (obj2) {
55101 ecode3 = SWIG_AsVal_int(obj2, &val3);
55102 if (!SWIG_IsOK(ecode3)) {
55103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55104 }
55105 arg3 = static_cast< int >(val3);
55106 }
55107 {
55108 PyThreadState* __tstate = wxPyBeginAllowThreads();
55109 (arg1)->LeftOf(arg2,arg3);
55110 wxPyEndAllowThreads(__tstate);
55111 if (PyErr_Occurred()) SWIG_fail;
55112 }
55113 resultobj = SWIG_Py_Void();
55114 return resultobj;
55115 fail:
55116 return NULL;
55117 }
55118
55119
55120 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55121 PyObject *resultobj = 0;
55122 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55123 wxWindow *arg2 = (wxWindow *) 0 ;
55124 int arg3 = (int) 0 ;
55125 void *argp1 = 0 ;
55126 int res1 = 0 ;
55127 void *argp2 = 0 ;
55128 int res2 = 0 ;
55129 int val3 ;
55130 int ecode3 = 0 ;
55131 PyObject * obj0 = 0 ;
55132 PyObject * obj1 = 0 ;
55133 PyObject * obj2 = 0 ;
55134 char * kwnames[] = {
55135 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55136 };
55137
55138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55140 if (!SWIG_IsOK(res1)) {
55141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55142 }
55143 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55145 if (!SWIG_IsOK(res2)) {
55146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55147 }
55148 arg2 = reinterpret_cast< wxWindow * >(argp2);
55149 if (obj2) {
55150 ecode3 = SWIG_AsVal_int(obj2, &val3);
55151 if (!SWIG_IsOK(ecode3)) {
55152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55153 }
55154 arg3 = static_cast< int >(val3);
55155 }
55156 {
55157 PyThreadState* __tstate = wxPyBeginAllowThreads();
55158 (arg1)->RightOf(arg2,arg3);
55159 wxPyEndAllowThreads(__tstate);
55160 if (PyErr_Occurred()) SWIG_fail;
55161 }
55162 resultobj = SWIG_Py_Void();
55163 return resultobj;
55164 fail:
55165 return NULL;
55166 }
55167
55168
55169 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55170 PyObject *resultobj = 0;
55171 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55172 wxWindow *arg2 = (wxWindow *) 0 ;
55173 int arg3 = (int) 0 ;
55174 void *argp1 = 0 ;
55175 int res1 = 0 ;
55176 void *argp2 = 0 ;
55177 int res2 = 0 ;
55178 int val3 ;
55179 int ecode3 = 0 ;
55180 PyObject * obj0 = 0 ;
55181 PyObject * obj1 = 0 ;
55182 PyObject * obj2 = 0 ;
55183 char * kwnames[] = {
55184 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55185 };
55186
55187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55189 if (!SWIG_IsOK(res1)) {
55190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55191 }
55192 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55193 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55194 if (!SWIG_IsOK(res2)) {
55195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55196 }
55197 arg2 = reinterpret_cast< wxWindow * >(argp2);
55198 if (obj2) {
55199 ecode3 = SWIG_AsVal_int(obj2, &val3);
55200 if (!SWIG_IsOK(ecode3)) {
55201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55202 }
55203 arg3 = static_cast< int >(val3);
55204 }
55205 {
55206 PyThreadState* __tstate = wxPyBeginAllowThreads();
55207 (arg1)->Above(arg2,arg3);
55208 wxPyEndAllowThreads(__tstate);
55209 if (PyErr_Occurred()) SWIG_fail;
55210 }
55211 resultobj = SWIG_Py_Void();
55212 return resultobj;
55213 fail:
55214 return NULL;
55215 }
55216
55217
55218 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55219 PyObject *resultobj = 0;
55220 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55221 wxWindow *arg2 = (wxWindow *) 0 ;
55222 int arg3 = (int) 0 ;
55223 void *argp1 = 0 ;
55224 int res1 = 0 ;
55225 void *argp2 = 0 ;
55226 int res2 = 0 ;
55227 int val3 ;
55228 int ecode3 = 0 ;
55229 PyObject * obj0 = 0 ;
55230 PyObject * obj1 = 0 ;
55231 PyObject * obj2 = 0 ;
55232 char * kwnames[] = {
55233 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55234 };
55235
55236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55238 if (!SWIG_IsOK(res1)) {
55239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55240 }
55241 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55243 if (!SWIG_IsOK(res2)) {
55244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55245 }
55246 arg2 = reinterpret_cast< wxWindow * >(argp2);
55247 if (obj2) {
55248 ecode3 = SWIG_AsVal_int(obj2, &val3);
55249 if (!SWIG_IsOK(ecode3)) {
55250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55251 }
55252 arg3 = static_cast< int >(val3);
55253 }
55254 {
55255 PyThreadState* __tstate = wxPyBeginAllowThreads();
55256 (arg1)->Below(arg2,arg3);
55257 wxPyEndAllowThreads(__tstate);
55258 if (PyErr_Occurred()) SWIG_fail;
55259 }
55260 resultobj = SWIG_Py_Void();
55261 return resultobj;
55262 fail:
55263 return NULL;
55264 }
55265
55266
55267 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55268 PyObject *resultobj = 0;
55269 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55270 wxWindow *arg2 = (wxWindow *) 0 ;
55271 wxEdge arg3 ;
55272 int arg4 = (int) 0 ;
55273 void *argp1 = 0 ;
55274 int res1 = 0 ;
55275 void *argp2 = 0 ;
55276 int res2 = 0 ;
55277 int val3 ;
55278 int ecode3 = 0 ;
55279 int val4 ;
55280 int ecode4 = 0 ;
55281 PyObject * obj0 = 0 ;
55282 PyObject * obj1 = 0 ;
55283 PyObject * obj2 = 0 ;
55284 PyObject * obj3 = 0 ;
55285 char * kwnames[] = {
55286 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55287 };
55288
55289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55291 if (!SWIG_IsOK(res1)) {
55292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55293 }
55294 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55296 if (!SWIG_IsOK(res2)) {
55297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55298 }
55299 arg2 = reinterpret_cast< wxWindow * >(argp2);
55300 ecode3 = SWIG_AsVal_int(obj2, &val3);
55301 if (!SWIG_IsOK(ecode3)) {
55302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55303 }
55304 arg3 = static_cast< wxEdge >(val3);
55305 if (obj3) {
55306 ecode4 = SWIG_AsVal_int(obj3, &val4);
55307 if (!SWIG_IsOK(ecode4)) {
55308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55309 }
55310 arg4 = static_cast< int >(val4);
55311 }
55312 {
55313 PyThreadState* __tstate = wxPyBeginAllowThreads();
55314 (arg1)->SameAs(arg2,arg3,arg4);
55315 wxPyEndAllowThreads(__tstate);
55316 if (PyErr_Occurred()) SWIG_fail;
55317 }
55318 resultobj = SWIG_Py_Void();
55319 return resultobj;
55320 fail:
55321 return NULL;
55322 }
55323
55324
55325 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55326 PyObject *resultobj = 0;
55327 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55328 wxWindow *arg2 = (wxWindow *) 0 ;
55329 wxEdge arg3 ;
55330 int arg4 ;
55331 void *argp1 = 0 ;
55332 int res1 = 0 ;
55333 void *argp2 = 0 ;
55334 int res2 = 0 ;
55335 int val3 ;
55336 int ecode3 = 0 ;
55337 int val4 ;
55338 int ecode4 = 0 ;
55339 PyObject * obj0 = 0 ;
55340 PyObject * obj1 = 0 ;
55341 PyObject * obj2 = 0 ;
55342 PyObject * obj3 = 0 ;
55343 char * kwnames[] = {
55344 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55345 };
55346
55347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55349 if (!SWIG_IsOK(res1)) {
55350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55351 }
55352 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55353 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55354 if (!SWIG_IsOK(res2)) {
55355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55356 }
55357 arg2 = reinterpret_cast< wxWindow * >(argp2);
55358 ecode3 = SWIG_AsVal_int(obj2, &val3);
55359 if (!SWIG_IsOK(ecode3)) {
55360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55361 }
55362 arg3 = static_cast< wxEdge >(val3);
55363 ecode4 = SWIG_AsVal_int(obj3, &val4);
55364 if (!SWIG_IsOK(ecode4)) {
55365 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55366 }
55367 arg4 = static_cast< int >(val4);
55368 {
55369 PyThreadState* __tstate = wxPyBeginAllowThreads();
55370 (arg1)->PercentOf(arg2,arg3,arg4);
55371 wxPyEndAllowThreads(__tstate);
55372 if (PyErr_Occurred()) SWIG_fail;
55373 }
55374 resultobj = SWIG_Py_Void();
55375 return resultobj;
55376 fail:
55377 return NULL;
55378 }
55379
55380
55381 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55382 PyObject *resultobj = 0;
55383 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55384 int arg2 ;
55385 void *argp1 = 0 ;
55386 int res1 = 0 ;
55387 int val2 ;
55388 int ecode2 = 0 ;
55389 PyObject * obj0 = 0 ;
55390 PyObject * obj1 = 0 ;
55391 char * kwnames[] = {
55392 (char *) "self",(char *) "val", NULL
55393 };
55394
55395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55397 if (!SWIG_IsOK(res1)) {
55398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55399 }
55400 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55401 ecode2 = SWIG_AsVal_int(obj1, &val2);
55402 if (!SWIG_IsOK(ecode2)) {
55403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55404 }
55405 arg2 = static_cast< int >(val2);
55406 {
55407 PyThreadState* __tstate = wxPyBeginAllowThreads();
55408 (arg1)->Absolute(arg2);
55409 wxPyEndAllowThreads(__tstate);
55410 if (PyErr_Occurred()) SWIG_fail;
55411 }
55412 resultobj = SWIG_Py_Void();
55413 return resultobj;
55414 fail:
55415 return NULL;
55416 }
55417
55418
55419 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55420 PyObject *resultobj = 0;
55421 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55422 void *argp1 = 0 ;
55423 int res1 = 0 ;
55424 PyObject *swig_obj[1] ;
55425
55426 if (!args) SWIG_fail;
55427 swig_obj[0] = args;
55428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55429 if (!SWIG_IsOK(res1)) {
55430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55431 }
55432 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55433 {
55434 PyThreadState* __tstate = wxPyBeginAllowThreads();
55435 (arg1)->Unconstrained();
55436 wxPyEndAllowThreads(__tstate);
55437 if (PyErr_Occurred()) SWIG_fail;
55438 }
55439 resultobj = SWIG_Py_Void();
55440 return resultobj;
55441 fail:
55442 return NULL;
55443 }
55444
55445
55446 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55447 PyObject *resultobj = 0;
55448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55449 void *argp1 = 0 ;
55450 int res1 = 0 ;
55451 PyObject *swig_obj[1] ;
55452
55453 if (!args) SWIG_fail;
55454 swig_obj[0] = args;
55455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55456 if (!SWIG_IsOK(res1)) {
55457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55458 }
55459 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55460 {
55461 PyThreadState* __tstate = wxPyBeginAllowThreads();
55462 (arg1)->AsIs();
55463 wxPyEndAllowThreads(__tstate);
55464 if (PyErr_Occurred()) SWIG_fail;
55465 }
55466 resultobj = SWIG_Py_Void();
55467 return resultobj;
55468 fail:
55469 return NULL;
55470 }
55471
55472
55473 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55474 PyObject *resultobj = 0;
55475 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55476 wxWindow *result = 0 ;
55477 void *argp1 = 0 ;
55478 int res1 = 0 ;
55479 PyObject *swig_obj[1] ;
55480
55481 if (!args) SWIG_fail;
55482 swig_obj[0] = args;
55483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55484 if (!SWIG_IsOK(res1)) {
55485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55486 }
55487 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55488 {
55489 PyThreadState* __tstate = wxPyBeginAllowThreads();
55490 result = (wxWindow *)(arg1)->GetOtherWindow();
55491 wxPyEndAllowThreads(__tstate);
55492 if (PyErr_Occurred()) SWIG_fail;
55493 }
55494 {
55495 resultobj = wxPyMake_wxObject(result, 0);
55496 }
55497 return resultobj;
55498 fail:
55499 return NULL;
55500 }
55501
55502
55503 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55504 PyObject *resultobj = 0;
55505 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55506 wxEdge result;
55507 void *argp1 = 0 ;
55508 int res1 = 0 ;
55509 PyObject *swig_obj[1] ;
55510
55511 if (!args) SWIG_fail;
55512 swig_obj[0] = args;
55513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55514 if (!SWIG_IsOK(res1)) {
55515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55516 }
55517 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55518 {
55519 PyThreadState* __tstate = wxPyBeginAllowThreads();
55520 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55521 wxPyEndAllowThreads(__tstate);
55522 if (PyErr_Occurred()) SWIG_fail;
55523 }
55524 resultobj = SWIG_From_int(static_cast< int >(result));
55525 return resultobj;
55526 fail:
55527 return NULL;
55528 }
55529
55530
55531 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55532 PyObject *resultobj = 0;
55533 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55534 wxEdge arg2 ;
55535 void *argp1 = 0 ;
55536 int res1 = 0 ;
55537 int val2 ;
55538 int ecode2 = 0 ;
55539 PyObject * obj0 = 0 ;
55540 PyObject * obj1 = 0 ;
55541 char * kwnames[] = {
55542 (char *) "self",(char *) "which", NULL
55543 };
55544
55545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55547 if (!SWIG_IsOK(res1)) {
55548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55549 }
55550 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55551 ecode2 = SWIG_AsVal_int(obj1, &val2);
55552 if (!SWIG_IsOK(ecode2)) {
55553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55554 }
55555 arg2 = static_cast< wxEdge >(val2);
55556 {
55557 PyThreadState* __tstate = wxPyBeginAllowThreads();
55558 (arg1)->SetEdge(arg2);
55559 wxPyEndAllowThreads(__tstate);
55560 if (PyErr_Occurred()) SWIG_fail;
55561 }
55562 resultobj = SWIG_Py_Void();
55563 return resultobj;
55564 fail:
55565 return NULL;
55566 }
55567
55568
55569 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55570 PyObject *resultobj = 0;
55571 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55572 int arg2 ;
55573 void *argp1 = 0 ;
55574 int res1 = 0 ;
55575 int val2 ;
55576 int ecode2 = 0 ;
55577 PyObject * obj0 = 0 ;
55578 PyObject * obj1 = 0 ;
55579 char * kwnames[] = {
55580 (char *) "self",(char *) "v", NULL
55581 };
55582
55583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55585 if (!SWIG_IsOK(res1)) {
55586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55587 }
55588 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55589 ecode2 = SWIG_AsVal_int(obj1, &val2);
55590 if (!SWIG_IsOK(ecode2)) {
55591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55592 }
55593 arg2 = static_cast< int >(val2);
55594 {
55595 PyThreadState* __tstate = wxPyBeginAllowThreads();
55596 (arg1)->SetValue(arg2);
55597 wxPyEndAllowThreads(__tstate);
55598 if (PyErr_Occurred()) SWIG_fail;
55599 }
55600 resultobj = SWIG_Py_Void();
55601 return resultobj;
55602 fail:
55603 return NULL;
55604 }
55605
55606
55607 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55608 PyObject *resultobj = 0;
55609 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55610 int result;
55611 void *argp1 = 0 ;
55612 int res1 = 0 ;
55613 PyObject *swig_obj[1] ;
55614
55615 if (!args) SWIG_fail;
55616 swig_obj[0] = args;
55617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55618 if (!SWIG_IsOK(res1)) {
55619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55620 }
55621 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55622 {
55623 PyThreadState* __tstate = wxPyBeginAllowThreads();
55624 result = (int)(arg1)->GetMargin();
55625 wxPyEndAllowThreads(__tstate);
55626 if (PyErr_Occurred()) SWIG_fail;
55627 }
55628 resultobj = SWIG_From_int(static_cast< int >(result));
55629 return resultobj;
55630 fail:
55631 return NULL;
55632 }
55633
55634
55635 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55636 PyObject *resultobj = 0;
55637 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55638 int arg2 ;
55639 void *argp1 = 0 ;
55640 int res1 = 0 ;
55641 int val2 ;
55642 int ecode2 = 0 ;
55643 PyObject * obj0 = 0 ;
55644 PyObject * obj1 = 0 ;
55645 char * kwnames[] = {
55646 (char *) "self",(char *) "m", NULL
55647 };
55648
55649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55651 if (!SWIG_IsOK(res1)) {
55652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55653 }
55654 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55655 ecode2 = SWIG_AsVal_int(obj1, &val2);
55656 if (!SWIG_IsOK(ecode2)) {
55657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55658 }
55659 arg2 = static_cast< int >(val2);
55660 {
55661 PyThreadState* __tstate = wxPyBeginAllowThreads();
55662 (arg1)->SetMargin(arg2);
55663 wxPyEndAllowThreads(__tstate);
55664 if (PyErr_Occurred()) SWIG_fail;
55665 }
55666 resultobj = SWIG_Py_Void();
55667 return resultobj;
55668 fail:
55669 return NULL;
55670 }
55671
55672
55673 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55674 PyObject *resultobj = 0;
55675 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55676 int result;
55677 void *argp1 = 0 ;
55678 int res1 = 0 ;
55679 PyObject *swig_obj[1] ;
55680
55681 if (!args) SWIG_fail;
55682 swig_obj[0] = args;
55683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55684 if (!SWIG_IsOK(res1)) {
55685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55686 }
55687 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55688 {
55689 PyThreadState* __tstate = wxPyBeginAllowThreads();
55690 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55691 wxPyEndAllowThreads(__tstate);
55692 if (PyErr_Occurred()) SWIG_fail;
55693 }
55694 resultobj = SWIG_From_int(static_cast< int >(result));
55695 return resultobj;
55696 fail:
55697 return NULL;
55698 }
55699
55700
55701 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55702 PyObject *resultobj = 0;
55703 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55704 int result;
55705 void *argp1 = 0 ;
55706 int res1 = 0 ;
55707 PyObject *swig_obj[1] ;
55708
55709 if (!args) SWIG_fail;
55710 swig_obj[0] = args;
55711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55712 if (!SWIG_IsOK(res1)) {
55713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55714 }
55715 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55716 {
55717 PyThreadState* __tstate = wxPyBeginAllowThreads();
55718 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55719 wxPyEndAllowThreads(__tstate);
55720 if (PyErr_Occurred()) SWIG_fail;
55721 }
55722 resultobj = SWIG_From_int(static_cast< int >(result));
55723 return resultobj;
55724 fail:
55725 return NULL;
55726 }
55727
55728
55729 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55730 PyObject *resultobj = 0;
55731 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55732 int result;
55733 void *argp1 = 0 ;
55734 int res1 = 0 ;
55735 PyObject *swig_obj[1] ;
55736
55737 if (!args) SWIG_fail;
55738 swig_obj[0] = args;
55739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55740 if (!SWIG_IsOK(res1)) {
55741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55742 }
55743 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55744 {
55745 PyThreadState* __tstate = wxPyBeginAllowThreads();
55746 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55747 wxPyEndAllowThreads(__tstate);
55748 if (PyErr_Occurred()) SWIG_fail;
55749 }
55750 resultobj = SWIG_From_int(static_cast< int >(result));
55751 return resultobj;
55752 fail:
55753 return NULL;
55754 }
55755
55756
55757 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55758 PyObject *resultobj = 0;
55759 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55760 bool result;
55761 void *argp1 = 0 ;
55762 int res1 = 0 ;
55763 PyObject *swig_obj[1] ;
55764
55765 if (!args) SWIG_fail;
55766 swig_obj[0] = args;
55767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55768 if (!SWIG_IsOK(res1)) {
55769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55770 }
55771 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55772 {
55773 PyThreadState* __tstate = wxPyBeginAllowThreads();
55774 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55775 wxPyEndAllowThreads(__tstate);
55776 if (PyErr_Occurred()) SWIG_fail;
55777 }
55778 {
55779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55780 }
55781 return resultobj;
55782 fail:
55783 return NULL;
55784 }
55785
55786
55787 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55788 PyObject *resultobj = 0;
55789 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55790 bool arg2 ;
55791 void *argp1 = 0 ;
55792 int res1 = 0 ;
55793 bool val2 ;
55794 int ecode2 = 0 ;
55795 PyObject * obj0 = 0 ;
55796 PyObject * obj1 = 0 ;
55797 char * kwnames[] = {
55798 (char *) "self",(char *) "d", NULL
55799 };
55800
55801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55803 if (!SWIG_IsOK(res1)) {
55804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55805 }
55806 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55807 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55808 if (!SWIG_IsOK(ecode2)) {
55809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55810 }
55811 arg2 = static_cast< bool >(val2);
55812 {
55813 PyThreadState* __tstate = wxPyBeginAllowThreads();
55814 (arg1)->SetDone(arg2);
55815 wxPyEndAllowThreads(__tstate);
55816 if (PyErr_Occurred()) SWIG_fail;
55817 }
55818 resultobj = SWIG_Py_Void();
55819 return resultobj;
55820 fail:
55821 return NULL;
55822 }
55823
55824
55825 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55826 PyObject *resultobj = 0;
55827 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55828 wxRelationship result;
55829 void *argp1 = 0 ;
55830 int res1 = 0 ;
55831 PyObject *swig_obj[1] ;
55832
55833 if (!args) SWIG_fail;
55834 swig_obj[0] = args;
55835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55836 if (!SWIG_IsOK(res1)) {
55837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55838 }
55839 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55840 {
55841 PyThreadState* __tstate = wxPyBeginAllowThreads();
55842 result = (wxRelationship)(arg1)->GetRelationship();
55843 wxPyEndAllowThreads(__tstate);
55844 if (PyErr_Occurred()) SWIG_fail;
55845 }
55846 resultobj = SWIG_From_int(static_cast< int >(result));
55847 return resultobj;
55848 fail:
55849 return NULL;
55850 }
55851
55852
55853 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55854 PyObject *resultobj = 0;
55855 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55856 wxRelationship arg2 ;
55857 void *argp1 = 0 ;
55858 int res1 = 0 ;
55859 int val2 ;
55860 int ecode2 = 0 ;
55861 PyObject * obj0 = 0 ;
55862 PyObject * obj1 = 0 ;
55863 char * kwnames[] = {
55864 (char *) "self",(char *) "r", NULL
55865 };
55866
55867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55869 if (!SWIG_IsOK(res1)) {
55870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55871 }
55872 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55873 ecode2 = SWIG_AsVal_int(obj1, &val2);
55874 if (!SWIG_IsOK(ecode2)) {
55875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55876 }
55877 arg2 = static_cast< wxRelationship >(val2);
55878 {
55879 PyThreadState* __tstate = wxPyBeginAllowThreads();
55880 (arg1)->SetRelationship(arg2);
55881 wxPyEndAllowThreads(__tstate);
55882 if (PyErr_Occurred()) SWIG_fail;
55883 }
55884 resultobj = SWIG_Py_Void();
55885 return resultobj;
55886 fail:
55887 return NULL;
55888 }
55889
55890
55891 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55892 PyObject *resultobj = 0;
55893 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55894 wxWindow *arg2 = (wxWindow *) 0 ;
55895 bool result;
55896 void *argp1 = 0 ;
55897 int res1 = 0 ;
55898 void *argp2 = 0 ;
55899 int res2 = 0 ;
55900 PyObject * obj0 = 0 ;
55901 PyObject * obj1 = 0 ;
55902 char * kwnames[] = {
55903 (char *) "self",(char *) "otherW", NULL
55904 };
55905
55906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55908 if (!SWIG_IsOK(res1)) {
55909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55910 }
55911 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55912 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55913 if (!SWIG_IsOK(res2)) {
55914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55915 }
55916 arg2 = reinterpret_cast< wxWindow * >(argp2);
55917 {
55918 PyThreadState* __tstate = wxPyBeginAllowThreads();
55919 result = (bool)(arg1)->ResetIfWin(arg2);
55920 wxPyEndAllowThreads(__tstate);
55921 if (PyErr_Occurred()) SWIG_fail;
55922 }
55923 {
55924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55925 }
55926 return resultobj;
55927 fail:
55928 return NULL;
55929 }
55930
55931
55932 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55933 PyObject *resultobj = 0;
55934 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55935 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55936 wxWindow *arg3 = (wxWindow *) 0 ;
55937 bool result;
55938 void *argp1 = 0 ;
55939 int res1 = 0 ;
55940 void *argp2 = 0 ;
55941 int res2 = 0 ;
55942 void *argp3 = 0 ;
55943 int res3 = 0 ;
55944 PyObject * obj0 = 0 ;
55945 PyObject * obj1 = 0 ;
55946 PyObject * obj2 = 0 ;
55947 char * kwnames[] = {
55948 (char *) "self",(char *) "constraints",(char *) "win", NULL
55949 };
55950
55951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55953 if (!SWIG_IsOK(res1)) {
55954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55955 }
55956 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55957 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55958 if (!SWIG_IsOK(res2)) {
55959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
55960 }
55961 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
55962 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55963 if (!SWIG_IsOK(res3)) {
55964 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
55965 }
55966 arg3 = reinterpret_cast< wxWindow * >(argp3);
55967 {
55968 PyThreadState* __tstate = wxPyBeginAllowThreads();
55969 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
55970 wxPyEndAllowThreads(__tstate);
55971 if (PyErr_Occurred()) SWIG_fail;
55972 }
55973 {
55974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55975 }
55976 return resultobj;
55977 fail:
55978 return NULL;
55979 }
55980
55981
55982 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55983 PyObject *resultobj = 0;
55984 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55985 wxEdge arg2 ;
55986 wxWindow *arg3 = (wxWindow *) 0 ;
55987 wxWindow *arg4 = (wxWindow *) 0 ;
55988 int result;
55989 void *argp1 = 0 ;
55990 int res1 = 0 ;
55991 int val2 ;
55992 int ecode2 = 0 ;
55993 void *argp3 = 0 ;
55994 int res3 = 0 ;
55995 void *argp4 = 0 ;
55996 int res4 = 0 ;
55997 PyObject * obj0 = 0 ;
55998 PyObject * obj1 = 0 ;
55999 PyObject * obj2 = 0 ;
56000 PyObject * obj3 = 0 ;
56001 char * kwnames[] = {
56002 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56003 };
56004
56005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56007 if (!SWIG_IsOK(res1)) {
56008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56009 }
56010 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56011 ecode2 = SWIG_AsVal_int(obj1, &val2);
56012 if (!SWIG_IsOK(ecode2)) {
56013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56014 }
56015 arg2 = static_cast< wxEdge >(val2);
56016 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56017 if (!SWIG_IsOK(res3)) {
56018 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56019 }
56020 arg3 = reinterpret_cast< wxWindow * >(argp3);
56021 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56022 if (!SWIG_IsOK(res4)) {
56023 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56024 }
56025 arg4 = reinterpret_cast< wxWindow * >(argp4);
56026 {
56027 PyThreadState* __tstate = wxPyBeginAllowThreads();
56028 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56029 wxPyEndAllowThreads(__tstate);
56030 if (PyErr_Occurred()) SWIG_fail;
56031 }
56032 resultobj = SWIG_From_int(static_cast< int >(result));
56033 return resultobj;
56034 fail:
56035 return NULL;
56036 }
56037
56038
56039 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56040 PyObject *obj;
56041 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56042 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56043 return SWIG_Py_Void();
56044 }
56045
56046 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56047 PyObject *resultobj = 0;
56048 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56049 wxIndividualLayoutConstraint *result = 0 ;
56050 void *argp1 = 0 ;
56051 int res1 = 0 ;
56052 PyObject *swig_obj[1] ;
56053
56054 if (!args) SWIG_fail;
56055 swig_obj[0] = args;
56056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56057 if (!SWIG_IsOK(res1)) {
56058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56059 }
56060 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56061 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56063 return resultobj;
56064 fail:
56065 return NULL;
56066 }
56067
56068
56069 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56070 PyObject *resultobj = 0;
56071 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56072 wxIndividualLayoutConstraint *result = 0 ;
56073 void *argp1 = 0 ;
56074 int res1 = 0 ;
56075 PyObject *swig_obj[1] ;
56076
56077 if (!args) SWIG_fail;
56078 swig_obj[0] = args;
56079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56080 if (!SWIG_IsOK(res1)) {
56081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56082 }
56083 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56084 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56086 return resultobj;
56087 fail:
56088 return NULL;
56089 }
56090
56091
56092 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56093 PyObject *resultobj = 0;
56094 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56095 wxIndividualLayoutConstraint *result = 0 ;
56096 void *argp1 = 0 ;
56097 int res1 = 0 ;
56098 PyObject *swig_obj[1] ;
56099
56100 if (!args) SWIG_fail;
56101 swig_obj[0] = args;
56102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56103 if (!SWIG_IsOK(res1)) {
56104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56105 }
56106 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56107 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56109 return resultobj;
56110 fail:
56111 return NULL;
56112 }
56113
56114
56115 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56116 PyObject *resultobj = 0;
56117 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56118 wxIndividualLayoutConstraint *result = 0 ;
56119 void *argp1 = 0 ;
56120 int res1 = 0 ;
56121 PyObject *swig_obj[1] ;
56122
56123 if (!args) SWIG_fail;
56124 swig_obj[0] = args;
56125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56126 if (!SWIG_IsOK(res1)) {
56127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56128 }
56129 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56130 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56132 return resultobj;
56133 fail:
56134 return NULL;
56135 }
56136
56137
56138 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56139 PyObject *resultobj = 0;
56140 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56141 wxIndividualLayoutConstraint *result = 0 ;
56142 void *argp1 = 0 ;
56143 int res1 = 0 ;
56144 PyObject *swig_obj[1] ;
56145
56146 if (!args) SWIG_fail;
56147 swig_obj[0] = args;
56148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56149 if (!SWIG_IsOK(res1)) {
56150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56151 }
56152 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56153 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56155 return resultobj;
56156 fail:
56157 return NULL;
56158 }
56159
56160
56161 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56162 PyObject *resultobj = 0;
56163 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56164 wxIndividualLayoutConstraint *result = 0 ;
56165 void *argp1 = 0 ;
56166 int res1 = 0 ;
56167 PyObject *swig_obj[1] ;
56168
56169 if (!args) SWIG_fail;
56170 swig_obj[0] = args;
56171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56172 if (!SWIG_IsOK(res1)) {
56173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56174 }
56175 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56176 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56178 return resultobj;
56179 fail:
56180 return NULL;
56181 }
56182
56183
56184 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56185 PyObject *resultobj = 0;
56186 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56187 wxIndividualLayoutConstraint *result = 0 ;
56188 void *argp1 = 0 ;
56189 int res1 = 0 ;
56190 PyObject *swig_obj[1] ;
56191
56192 if (!args) SWIG_fail;
56193 swig_obj[0] = args;
56194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56195 if (!SWIG_IsOK(res1)) {
56196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56197 }
56198 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56199 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56201 return resultobj;
56202 fail:
56203 return NULL;
56204 }
56205
56206
56207 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56208 PyObject *resultobj = 0;
56209 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56210 wxIndividualLayoutConstraint *result = 0 ;
56211 void *argp1 = 0 ;
56212 int res1 = 0 ;
56213 PyObject *swig_obj[1] ;
56214
56215 if (!args) SWIG_fail;
56216 swig_obj[0] = args;
56217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56218 if (!SWIG_IsOK(res1)) {
56219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56220 }
56221 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56222 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56224 return resultobj;
56225 fail:
56226 return NULL;
56227 }
56228
56229
56230 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56231 PyObject *resultobj = 0;
56232 wxLayoutConstraints *result = 0 ;
56233
56234 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56235 {
56236 PyThreadState* __tstate = wxPyBeginAllowThreads();
56237 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56238 wxPyEndAllowThreads(__tstate);
56239 if (PyErr_Occurred()) SWIG_fail;
56240 }
56241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56242 return resultobj;
56243 fail:
56244 return NULL;
56245 }
56246
56247
56248 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56249 PyObject *resultobj = 0;
56250 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56251 void *argp1 = 0 ;
56252 int res1 = 0 ;
56253 PyObject *swig_obj[1] ;
56254
56255 if (!args) SWIG_fail;
56256 swig_obj[0] = args;
56257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56258 if (!SWIG_IsOK(res1)) {
56259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56260 }
56261 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56262 {
56263 PyThreadState* __tstate = wxPyBeginAllowThreads();
56264 delete arg1;
56265
56266 wxPyEndAllowThreads(__tstate);
56267 if (PyErr_Occurred()) SWIG_fail;
56268 }
56269 resultobj = SWIG_Py_Void();
56270 return resultobj;
56271 fail:
56272 return NULL;
56273 }
56274
56275
56276 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56277 PyObject *resultobj = 0;
56278 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56279 wxWindow *arg2 = (wxWindow *) 0 ;
56280 int *arg3 = (int *) 0 ;
56281 bool result;
56282 void *argp1 = 0 ;
56283 int res1 = 0 ;
56284 void *argp2 = 0 ;
56285 int res2 = 0 ;
56286 int temp3 ;
56287 int res3 = SWIG_TMPOBJ ;
56288 PyObject * obj0 = 0 ;
56289 PyObject * obj1 = 0 ;
56290 char * kwnames[] = {
56291 (char *) "self",(char *) "win", NULL
56292 };
56293
56294 arg3 = &temp3;
56295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56297 if (!SWIG_IsOK(res1)) {
56298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56299 }
56300 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56301 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56302 if (!SWIG_IsOK(res2)) {
56303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56304 }
56305 arg2 = reinterpret_cast< wxWindow * >(argp2);
56306 {
56307 PyThreadState* __tstate = wxPyBeginAllowThreads();
56308 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56309 wxPyEndAllowThreads(__tstate);
56310 if (PyErr_Occurred()) SWIG_fail;
56311 }
56312 {
56313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56314 }
56315 if (SWIG_IsTmpObj(res3)) {
56316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56317 } else {
56318 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56319 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56320 }
56321 return resultobj;
56322 fail:
56323 return NULL;
56324 }
56325
56326
56327 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56328 PyObject *resultobj = 0;
56329 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56330 bool result;
56331 void *argp1 = 0 ;
56332 int res1 = 0 ;
56333 PyObject *swig_obj[1] ;
56334
56335 if (!args) SWIG_fail;
56336 swig_obj[0] = args;
56337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56338 if (!SWIG_IsOK(res1)) {
56339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56340 }
56341 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56342 {
56343 PyThreadState* __tstate = wxPyBeginAllowThreads();
56344 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56345 wxPyEndAllowThreads(__tstate);
56346 if (PyErr_Occurred()) SWIG_fail;
56347 }
56348 {
56349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56350 }
56351 return resultobj;
56352 fail:
56353 return NULL;
56354 }
56355
56356
56357 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56358 PyObject *obj;
56359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56360 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56361 return SWIG_Py_Void();
56362 }
56363
56364 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56365 return SWIG_Python_InitShadowInstance(args);
56366 }
56367
56368 static PyMethodDef SwigMethods[] = {
56369 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56370 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56371 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56372 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56373 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56374 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56375 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56376 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56377 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56378 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56379 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56380 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56381 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56382 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56383 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56384 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56385 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56386 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56387 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56388 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56389 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56390 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56391 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56392 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56393 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56394 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56395 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56396 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56397 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56398 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56399 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56400 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56401 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56402 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56403 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56404 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56405 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56406 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56407 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56408 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56409 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56410 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56411 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56412 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56413 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56414 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56415 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56416 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56417 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56418 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56419 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56420 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56421 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56422 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56423 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56424 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56425 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56426 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56427 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56428 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56429 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56430 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56431 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56432 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56433 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56434 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56435 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56437 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56439 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56440 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56441 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56442 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56443 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56445 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56447 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56448 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56450 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56451 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56452 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56453 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56454 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56455 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56456 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56457 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56458 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56459 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56466 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56467 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56468 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56470 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56471 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56474 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56475 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56479 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56480 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56481 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56482 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56483 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56484 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56485 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56486 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56488 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56489 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56490 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56491 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56492 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56493 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56495 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56496 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56497 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56498 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56499 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56500 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56506 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56509 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56513 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56514 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56515 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56516 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56518 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56519 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56520 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56522 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56523 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56524 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56525 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56528 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56529 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56531 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56534 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56537 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56538 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56540 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56543 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56546 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56549 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56553 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56554 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56555 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56557 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56560 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56561 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56562 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56563 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56564 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56566 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56567 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56568 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56569 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56570 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56571 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56572 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56573 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56574 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56575 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56576 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56577 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56578 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56579 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56580 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56582 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56583 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56584 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56585 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56588 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56590 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56591 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56592 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56593 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56594 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56595 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56596 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56597 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56598 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56599 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56600 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56602 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56603 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56605 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56606 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56607 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56608 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56609 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56610 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56611 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56612 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56613 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56614 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56615 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56616 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56621 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56627 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56628 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56629 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56630 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56632 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56635 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56638 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56639 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56641 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56642 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56643 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56646 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56647 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56648 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56650 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56651 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56652 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56653 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56654 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56655 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56658 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56663 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56664 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56665 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56666 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56667 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56668 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56669 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56675 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56676 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56677 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56678 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56679 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56680 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56681 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56682 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56683 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56686 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56687 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56688 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56689 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56690 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56691 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56692 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56693 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56694 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56695 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56696 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56697 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56699 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56700 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56701 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56702 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56703 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56704 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56705 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56706 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56708 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56717 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56719 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56734 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56735 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56745 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56750 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56751 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56752 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56753 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56756 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56758 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56760 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56762 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56764 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56767 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56768 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56769 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56770 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56772 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56774 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56775 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56789 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56790 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56796 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56797 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56798 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56799 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56800 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56801 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56802 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56803 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56804 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56805 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56806 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56807 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56808 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56809 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56810 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56811 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56812 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56813 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56814 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56815 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56816 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56817 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56818 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56819 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56820 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56821 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56822 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56823 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56824 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56825 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56826 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56827 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56828 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56829 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56830 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56831 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56832 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56833 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56834 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56836 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56837 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56838 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56839 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56841 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56842 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56844 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56846 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56848 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56850 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56851 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56852 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56853 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56854 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56855 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56856 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56858 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56860 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56862 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56863 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56864 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56865 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56866 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56867 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56868 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56869 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56870 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56871 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56872 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56873 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56875 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56876 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56877 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56878 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56879 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56880 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56881 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56882 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56883 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56885 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56886 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56887 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56888 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56889 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56890 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56891 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56892 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56893 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56894 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56895 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56896 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56897 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56898 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56899 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56900 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56901 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56902 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56903 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56904 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56905 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56906 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56907 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56908 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56909 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56910 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56911 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56912 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56913 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56914 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56915 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56916 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56917 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56918 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56919 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56920 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56921 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56922 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56923 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56924 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56925 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56926 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56927 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56928 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56929 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56930 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56931 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56932 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56933 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56934 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56935 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56936 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56937 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56938 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56939 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56940 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56941 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56942 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56943 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56944 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56945 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56946 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56947 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56948 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56949 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56950 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56951 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56952 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56953 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56954 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56955 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56956 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56957 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56958 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56959 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
56960 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
56961 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
56962 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
56963 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
56964 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
56965 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
56966 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
56967 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
56968 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
56969 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
56970 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
56971 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
56972 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
56973 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
56974 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
56975 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
56976 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56977 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
56978 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
56979 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
56980 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
56981 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
56982 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
56983 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
56984 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56985 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
56986 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
56987 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
56988 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
56989 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
56990 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
56991 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
56992 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
56993 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
56994 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56995 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
56996 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
56997 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
56998 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
56999 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57000 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57001 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57002 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57003 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57004 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57005 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57006 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57007 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57008 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57009 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57010 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57011 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57012 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57013 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57014 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57015 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57016 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57017 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57018 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57019 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57020 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57021 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57022 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57023 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57024 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57025 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57026 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57027 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57028 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57029 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57030 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57031 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57032 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57033 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57034 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57035 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57036 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57037 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57038 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57039 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57040 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57041 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57042 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57043 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57044 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57045 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57046 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57047 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57048 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57049 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57050 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57051 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57052 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57053 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57054 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57055 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57056 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57057 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57058 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57059 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57060 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57061 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57062 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57063 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57064 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57065 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57066 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57067 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57068 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57069 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57070 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57071 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57072 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57073 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57074 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57075 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57076 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57077 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57078 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57079 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57080 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57081 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57082 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57083 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57084 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57085 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57086 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57087 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57088 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57089 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57090 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57091 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57092 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57093 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57094 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57095 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57096 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57097 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57098 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57099 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57100 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57101 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57102 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57103 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57104 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57105 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57106 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57107 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57108 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57110 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57111 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57112 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57113 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57114 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57115 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57116 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57117 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57118 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57119 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57120 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57121 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57122 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57123 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57124 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57125 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57126 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57127 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57128 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57129 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57130 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57131 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57132 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57133 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57134 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57135 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57136 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57137 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57138 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57139 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57140 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57141 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57142 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57143 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57144 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57145 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57146 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57147 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57148 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57149 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57150 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57151 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57152 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57153 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57154 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57155 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57156 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57157 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57158 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57159 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57160 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57161 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57162 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57163 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57164 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57165 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57166 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57167 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57168 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57169 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57170 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57171 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57172 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57173 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57174 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57175 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57176 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57177 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57178 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57179 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57180 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57181 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57182 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57183 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57184 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57185 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57186 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57187 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57188 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57189 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57190 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57191 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57192 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57193 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57194 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57195 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57196 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57197 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57198 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57199 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57200 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57201 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57202 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57203 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57204 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57205 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57206 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57207 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57208 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57209 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57210 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57211 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57212 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57213 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57214 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57215 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57216 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57217 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57218 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57219 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57220 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57222 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57223 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57224 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57226 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57227 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57228 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57229 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57230 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57231 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57232 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57233 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57234 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57236 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57237 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57238 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57239 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57240 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57241 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57242 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57243 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57244 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57245 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57246 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57247 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57248 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57249 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57250 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57251 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57252 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57253 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57254 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57255 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57256 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57257 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57258 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57259 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57260 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57261 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57262 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57263 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57264 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57265 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57266 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57267 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57268 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57269 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57270 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57271 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57273 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57274 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57275 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57276 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57277 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57278 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57279 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57280 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57281 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57282 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57283 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57284 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57285 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57286 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57287 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57288 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57289 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57290 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57291 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57292 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57293 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57294 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57295 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57296 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57297 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57298 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57301 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57302 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57303 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57304 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57305 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57306 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57307 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57308 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57309 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57310 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57311 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57312 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57313 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57314 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57315 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57316 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57318 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57319 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57321 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57322 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57323 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57324 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57325 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57326 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57328 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57329 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57330 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57331 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57332 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57333 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57334 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57335 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57336 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57337 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57338 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57339 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57340 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57341 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57342 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57343 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57344 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57345 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57346 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57347 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57348 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57349 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57350 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57351 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57355 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57356 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57357 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57358 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57359 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57360 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57361 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57362 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57363 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57365 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57366 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57367 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57368 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57369 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57370 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57371 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57372 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57373 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57374 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57376 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57378 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57380 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57383 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57384 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57385 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57386 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57387 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57388 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57390 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57392 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57393 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57394 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57395 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57400 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57402 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57406 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57408 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57409 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57410 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57411 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57412 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57414 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57415 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57416 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57420 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57421 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57422 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57423 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57424 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57425 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57426 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57427 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57430 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57431 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57432 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57433 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57434 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57435 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57436 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57437 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57438 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57442 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57447 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57448 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57449 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57450 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57451 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57453 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57454 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57456 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57459 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57461 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57462 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57463 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57472 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57476 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57477 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57479 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57485 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57487 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57489 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57490 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57491 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57492 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57493 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57497 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57500 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57502 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57505 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57507 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57508 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57510 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57511 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57513 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57514 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57515 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57516 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57518 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57519 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57524 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57525 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57526 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57528 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57529 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57530 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57532 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57534 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57535 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57536 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57538 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57539 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57542 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57550 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57557 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57565 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57567 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57568 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57569 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57573 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57580 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57582 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57584 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57586 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57587 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57589 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57591 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57592 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57594 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57595 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57596 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57600 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57617 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57619 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57620 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57622 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57623 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57625 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57626 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57627 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57629 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57630 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57633 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57634 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57636 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57637 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57639 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57642 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57643 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57645 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57647 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57649 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57650 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57652 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57653 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57656 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57658 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57660 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57662 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57665 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57667 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57668 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57669 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57671 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57672 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57673 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57675 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57677 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57678 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57681 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57682 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57686 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57690 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57691 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57693 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57697 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57699 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57701 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57702 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57703 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57704 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57708 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57709 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57710 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57711 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57713 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57714 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57719 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57720 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57721 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57722 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57723 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57725 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57727 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57729 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57730 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57732 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57734 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57737 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57738 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57739 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57741 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57742 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57743 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57756 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57762 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57763 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57764 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57765 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57766 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57767 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57773 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57774 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57778 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57779 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57781 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57782 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57784 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57786 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57787 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57789 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57790 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57791 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57797 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57798 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57799 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57800 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57801 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57802 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57809 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57811 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57812 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57813 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57814 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57815 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57816 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57818 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57822 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57823 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57824 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57825 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57826 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57827 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57828 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57830 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57831 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57832 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57838 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57839 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57840 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57842 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57843 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57844 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57849 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57850 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57851 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57852 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57853 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57854 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57858 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57859 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57864 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57865 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57867 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57868 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57873 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57875 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57876 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57877 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57878 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57879 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57884 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57885 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57894 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57895 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57896 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57897 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57898 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57900 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57902 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57903 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57904 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57905 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57907 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57912 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57913 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57914 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57915 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57916 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57917 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57918 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57919 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57920 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57921 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57922 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57924 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57925 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57926 { NULL, NULL, 0, NULL }
57927 };
57928
57929
57930 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57931
57932 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57933 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57934 }
57935 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57936 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57937 }
57938 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57939 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57940 }
57941 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57942 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57943 }
57944 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57945 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57946 }
57947 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57948 return (void *)((wxSizer *) ((wxGridSizer *) x));
57949 }
57950 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57951 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57952 }
57953 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57954 return (void *)((wxSizer *) ((wxPySizer *) x));
57955 }
57956 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57957 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57958 }
57959 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57960 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57961 }
57962 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
57963 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
57964 }
57965 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
57966 return (void *)((wxEvent *) ((wxMenuEvent *) x));
57967 }
57968 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
57969 return (void *)((wxEvent *) ((wxCloseEvent *) x));
57970 }
57971 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
57972 return (void *)((wxEvent *) ((wxMouseEvent *) x));
57973 }
57974 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
57975 return (void *)((wxEvent *) ((wxEraseEvent *) x));
57976 }
57977 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
57978 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
57979 }
57980 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
57981 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
57982 }
57983 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
57984 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
57985 }
57986 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
57987 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
57988 }
57989 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
57990 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
57991 }
57992 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
57993 return (void *)((wxEvent *) ((wxPyEvent *) x));
57994 }
57995 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
57996 return (void *)((wxEvent *) ((wxIdleEvent *) x));
57997 }
57998 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
57999 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58000 }
58001 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58002 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58003 }
58004 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58005 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58006 }
58007 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58008 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58009 }
58010 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58011 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58012 }
58013 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58014 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58015 }
58016 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58017 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58018 }
58019 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58020 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58021 }
58022 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58023 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58024 }
58025 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58026 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58027 }
58028 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58029 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58030 }
58031 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58032 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58033 }
58034 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58035 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58036 }
58037 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58038 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58039 }
58040 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58041 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58042 }
58043 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58044 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58045 }
58046 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58047 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58048 }
58049 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58050 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58051 }
58052 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58053 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58054 }
58055 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58056 return (void *)((wxEvent *) ((wxShowEvent *) x));
58057 }
58058 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58059 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58060 }
58061 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58062 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58063 }
58064 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58065 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58066 }
58067 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58068 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58069 }
58070 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58071 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58072 }
58073 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58074 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58075 }
58076 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58077 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58078 }
58079 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58080 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58081 }
58082 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58083 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58084 }
58085 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58086 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58087 }
58088 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58089 return (void *)((wxControl *) ((wxControlWithItems *) x));
58090 }
58091 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58092 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58093 }
58094 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58095 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58096 }
58097 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58098 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58099 }
58100 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58101 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58102 }
58103 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58104 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58105 }
58106 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58107 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58108 }
58109 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58110 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58111 }
58112 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58113 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58114 }
58115 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58116 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58117 }
58118 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58119 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58120 }
58121 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58122 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58123 }
58124 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58125 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58126 }
58127 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58128 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58129 }
58130 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58131 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58132 }
58133 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58134 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58135 }
58136 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58137 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58138 }
58139 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58140 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58141 }
58142 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58143 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58144 }
58145 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58146 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58147 }
58148 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58149 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58150 }
58151 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58152 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58153 }
58154 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58155 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58156 }
58157 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58158 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58159 }
58160 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58161 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58162 }
58163 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58164 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58165 }
58166 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58167 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58168 }
58169 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58170 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58171 }
58172 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58173 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58174 }
58175 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58176 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58177 }
58178 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58179 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58180 }
58181 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58182 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58183 }
58184 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58185 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58186 }
58187 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58188 return (void *)((wxObject *) ((wxSizerItem *) x));
58189 }
58190 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58191 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58192 }
58193 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58194 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58195 }
58196 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58197 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58198 }
58199 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58200 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58201 }
58202 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58203 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58204 }
58205 static void *_p_wxSizerTo_p_wxObject(void *x) {
58206 return (void *)((wxObject *) ((wxSizer *) x));
58207 }
58208 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58209 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58210 }
58211 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58212 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58213 }
58214 static void *_p_wxEventTo_p_wxObject(void *x) {
58215 return (void *)((wxObject *) ((wxEvent *) x));
58216 }
58217 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58218 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58219 }
58220 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58221 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58222 }
58223 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58224 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58225 }
58226 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58227 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58228 }
58229 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58230 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58231 }
58232 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58233 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58234 }
58235 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58236 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58237 }
58238 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58239 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58240 }
58241 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58242 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58243 }
58244 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58245 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58246 }
58247 static void *_p_wxControlTo_p_wxObject(void *x) {
58248 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58249 }
58250 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58251 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58252 }
58253 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58254 return (void *)((wxObject *) ((wxFSFile *) x));
58255 }
58256 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58257 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58258 }
58259 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58260 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58261 }
58262 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58263 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58264 }
58265 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58266 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58267 }
58268 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58269 return (void *)((wxObject *) ((wxMenuItem *) x));
58270 }
58271 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58272 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58273 }
58274 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58275 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58276 }
58277 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58278 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58279 }
58280 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58281 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58282 }
58283 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58284 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58285 }
58286 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58287 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58288 }
58289 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58290 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58291 }
58292 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58293 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58294 }
58295 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58296 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58297 }
58298 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58299 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58300 }
58301 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58302 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58303 }
58304 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58305 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58306 }
58307 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58308 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58309 }
58310 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58311 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58312 }
58313 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58314 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58315 }
58316 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58317 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58318 }
58319 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58320 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58321 }
58322 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58323 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58324 }
58325 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58326 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58327 }
58328 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58329 return (void *)((wxObject *) ((wxImageHandler *) x));
58330 }
58331 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58332 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58333 }
58334 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58335 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58336 }
58337 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58338 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58339 }
58340 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58341 return (void *)((wxObject *) ((wxEvtHandler *) x));
58342 }
58343 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58344 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58345 }
58346 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58347 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58348 }
58349 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58350 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58351 }
58352 static void *_p_wxImageTo_p_wxObject(void *x) {
58353 return (void *)((wxObject *) ((wxImage *) x));
58354 }
58355 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58356 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58357 }
58358 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58359 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58360 }
58361 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58362 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58363 }
58364 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58365 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58366 }
58367 static void *_p_wxWindowTo_p_wxObject(void *x) {
58368 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58369 }
58370 static void *_p_wxMenuTo_p_wxObject(void *x) {
58371 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58372 }
58373 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58374 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58375 }
58376 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58377 return (void *)((wxObject *) ((wxFileSystem *) x));
58378 }
58379 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58380 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58381 }
58382 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58383 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58384 }
58385 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58386 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58387 }
58388 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58389 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58390 }
58391 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58392 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58393 }
58394 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58395 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58396 }
58397 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58398 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58399 }
58400 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58401 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58402 }
58403 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58404 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58405 }
58406 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58407 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58408 }
58409 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58410 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58411 }
58412 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58413 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58414 }
58415 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58416 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58417 }
58418 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58419 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58420 }
58421 static void *_p_wxControlTo_p_wxWindow(void *x) {
58422 return (void *)((wxWindow *) ((wxControl *) x));
58423 }
58424 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58425 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58426 }
58427 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58428 return (void *)((wxWindow *) ((wxMenuBar *) x));
58429 }
58430 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58431 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58432 }
58433 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58434 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58435 }
58436 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58437 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58438 }
58439 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58440 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58441 }
58442 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58443 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58444 }
58445 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58446 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58447 }
58448 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58449 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58450 }
58451 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58452 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58453 }
58454 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58455 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58456 }
58457 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58458 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58459 }
58460 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58461 return (void *)((wxValidator *) ((wxPyValidator *) x));
58462 }
58463 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58464 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58465 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};
58466 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58467 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58468 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58469 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58470 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58471 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58472 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58473 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58474 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58475 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58476 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58477 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58478 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58479 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58480 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58481 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58482 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58483 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58484 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58485 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58486 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58487 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58488 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58489 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58490 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58491 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58492 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58493 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58494 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58495 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58496 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58497 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58498 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58499 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58598
58599 static swig_type_info *swig_type_initial[] = {
58600 &_swigt__p_buffer,
58601 &_swigt__p_char,
58602 &_swigt__p_form_ops_t,
58603 &_swigt__p_int,
58604 &_swigt__p_long,
58605 &_swigt__p_unsigned_char,
58606 &_swigt__p_unsigned_int,
58607 &_swigt__p_unsigned_long,
58608 &_swigt__p_wxANIHandler,
58609 &_swigt__p_wxAcceleratorEntry,
58610 &_swigt__p_wxAcceleratorTable,
58611 &_swigt__p_wxActivateEvent,
58612 &_swigt__p_wxAppTraits,
58613 &_swigt__p_wxArrayString,
58614 &_swigt__p_wxBMPHandler,
58615 &_swigt__p_wxBitmap,
58616 &_swigt__p_wxBoxSizer,
58617 &_swigt__p_wxButton,
58618 &_swigt__p_wxCURHandler,
58619 &_swigt__p_wxCaret,
58620 &_swigt__p_wxChildFocusEvent,
58621 &_swigt__p_wxClipboardTextEvent,
58622 &_swigt__p_wxCloseEvent,
58623 &_swigt__p_wxColour,
58624 &_swigt__p_wxCommandEvent,
58625 &_swigt__p_wxContextMenuEvent,
58626 &_swigt__p_wxControl,
58627 &_swigt__p_wxControlWithItems,
58628 &_swigt__p_wxCursor,
58629 &_swigt__p_wxDC,
58630 &_swigt__p_wxDateEvent,
58631 &_swigt__p_wxDateTime,
58632 &_swigt__p_wxDisplayChangedEvent,
58633 &_swigt__p_wxDouble,
58634 &_swigt__p_wxDropFilesEvent,
58635 &_swigt__p_wxDuplexMode,
58636 &_swigt__p_wxEraseEvent,
58637 &_swigt__p_wxEvent,
58638 &_swigt__p_wxEventLoop,
58639 &_swigt__p_wxEventLoopActivator,
58640 &_swigt__p_wxEvtHandler,
58641 &_swigt__p_wxFSFile,
58642 &_swigt__p_wxFileSystem,
58643 &_swigt__p_wxFileSystemHandler,
58644 &_swigt__p_wxFlexGridSizer,
58645 &_swigt__p_wxFocusEvent,
58646 &_swigt__p_wxFont,
58647 &_swigt__p_wxFrame,
58648 &_swigt__p_wxGBPosition,
58649 &_swigt__p_wxGBSizerItem,
58650 &_swigt__p_wxGBSpan,
58651 &_swigt__p_wxGIFHandler,
58652 &_swigt__p_wxGridBagSizer,
58653 &_swigt__p_wxGridSizer,
58654 &_swigt__p_wxHelpEvent__Origin,
58655 &_swigt__p_wxICOHandler,
58656 &_swigt__p_wxIconizeEvent,
58657 &_swigt__p_wxIdleEvent,
58658 &_swigt__p_wxImage,
58659 &_swigt__p_wxImageHandler,
58660 &_swigt__p_wxImageHistogram,
58661 &_swigt__p_wxImage_HSVValue,
58662 &_swigt__p_wxImage_RGBValue,
58663 &_swigt__p_wxIndividualLayoutConstraint,
58664 &_swigt__p_wxInitDialogEvent,
58665 &_swigt__p_wxInputStream,
58666 &_swigt__p_wxInternetFSHandler,
58667 &_swigt__p_wxItemContainer,
58668 &_swigt__p_wxJPEGHandler,
58669 &_swigt__p_wxKeyEvent,
58670 &_swigt__p_wxLayoutConstraints,
58671 &_swigt__p_wxMaximizeEvent,
58672 &_swigt__p_wxMemoryFSHandler,
58673 &_swigt__p_wxMenu,
58674 &_swigt__p_wxMenuBar,
58675 &_swigt__p_wxMenuBarBase,
58676 &_swigt__p_wxMenuEvent,
58677 &_swigt__p_wxMenuItem,
58678 &_swigt__p_wxMouseCaptureChangedEvent,
58679 &_swigt__p_wxMouseCaptureLostEvent,
58680 &_swigt__p_wxMouseEvent,
58681 &_swigt__p_wxMoveEvent,
58682 &_swigt__p_wxNavigationKeyEvent,
58683 &_swigt__p_wxNcPaintEvent,
58684 &_swigt__p_wxNotifyEvent,
58685 &_swigt__p_wxObject,
58686 &_swigt__p_wxOutputStream,
58687 &_swigt__p_wxPCXHandler,
58688 &_swigt__p_wxPNGHandler,
58689 &_swigt__p_wxPNMHandler,
58690 &_swigt__p_wxPaintEvent,
58691 &_swigt__p_wxPaletteChangedEvent,
58692 &_swigt__p_wxPaperSize,
58693 &_swigt__p_wxPoint,
58694 &_swigt__p_wxPoint2D,
58695 &_swigt__p_wxPropagateOnce,
58696 &_swigt__p_wxPropagationDisabler,
58697 &_swigt__p_wxPyApp,
58698 &_swigt__p_wxPyCommandEvent,
58699 &_swigt__p_wxPyDropTarget,
58700 &_swigt__p_wxPyEvent,
58701 &_swigt__p_wxPyFileSystemHandler,
58702 &_swigt__p_wxPyImageHandler,
58703 &_swigt__p_wxPyInputStream,
58704 &_swigt__p_wxPySizer,
58705 &_swigt__p_wxPyValidator,
58706 &_swigt__p_wxQuantize,
58707 &_swigt__p_wxQueryNewPaletteEvent,
58708 &_swigt__p_wxRealPoint,
58709 &_swigt__p_wxRect,
58710 &_swigt__p_wxRect2D,
58711 &_swigt__p_wxRegion,
58712 &_swigt__p_wxScrollEvent,
58713 &_swigt__p_wxScrollWinEvent,
58714 &_swigt__p_wxSetCursorEvent,
58715 &_swigt__p_wxShowEvent,
58716 &_swigt__p_wxSize,
58717 &_swigt__p_wxSizeEvent,
58718 &_swigt__p_wxSizer,
58719 &_swigt__p_wxSizerItem,
58720 &_swigt__p_wxStaticBox,
58721 &_swigt__p_wxStaticBoxSizer,
58722 &_swigt__p_wxStdDialogButtonSizer,
58723 &_swigt__p_wxSysColourChangedEvent,
58724 &_swigt__p_wxTGAHandler,
58725 &_swigt__p_wxTIFFHandler,
58726 &_swigt__p_wxToolTip,
58727 &_swigt__p_wxUpdateUIEvent,
58728 &_swigt__p_wxValidator,
58729 &_swigt__p_wxVisualAttributes,
58730 &_swigt__p_wxWindow,
58731 &_swigt__p_wxWindowCreateEvent,
58732 &_swigt__p_wxWindowDestroyEvent,
58733 &_swigt__p_wxXPMHandler,
58734 &_swigt__p_wxZipFSHandler,
58735 };
58736
58737 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58738 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58739 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58740 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58741 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58742 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58743 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58744 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58745 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58746 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58747 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58748 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58749 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58750 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58751 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}};
58752 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58753 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}};
58754 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58755 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}};
58756 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58757 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58758 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58759 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58760 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58761 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}};
58762 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58763 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}};
58764 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58765 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58766 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58767 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58768 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58769 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58770 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58771 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58772 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58773 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58774 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}};
58775 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58776 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58777 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}};
58778 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58779 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58780 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}};
58781 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}};
58782 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58783 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58784 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58785 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58786 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58788 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58789 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58790 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}};
58791 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58792 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}};
58793 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58794 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58795 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58796 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}};
58797 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58804 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}};
58805 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58807 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58808 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58811 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58822 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}};
58823 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58837 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58838 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58853 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58855 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}};
58856 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}};
58857 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58863 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58864 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58865 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}};
58866 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58867 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}};
58868 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58872
58873 static swig_cast_info *swig_cast_initial[] = {
58874 _swigc__p_buffer,
58875 _swigc__p_char,
58876 _swigc__p_form_ops_t,
58877 _swigc__p_int,
58878 _swigc__p_long,
58879 _swigc__p_unsigned_char,
58880 _swigc__p_unsigned_int,
58881 _swigc__p_unsigned_long,
58882 _swigc__p_wxANIHandler,
58883 _swigc__p_wxAcceleratorEntry,
58884 _swigc__p_wxAcceleratorTable,
58885 _swigc__p_wxActivateEvent,
58886 _swigc__p_wxAppTraits,
58887 _swigc__p_wxArrayString,
58888 _swigc__p_wxBMPHandler,
58889 _swigc__p_wxBitmap,
58890 _swigc__p_wxBoxSizer,
58891 _swigc__p_wxButton,
58892 _swigc__p_wxCURHandler,
58893 _swigc__p_wxCaret,
58894 _swigc__p_wxChildFocusEvent,
58895 _swigc__p_wxClipboardTextEvent,
58896 _swigc__p_wxCloseEvent,
58897 _swigc__p_wxColour,
58898 _swigc__p_wxCommandEvent,
58899 _swigc__p_wxContextMenuEvent,
58900 _swigc__p_wxControl,
58901 _swigc__p_wxControlWithItems,
58902 _swigc__p_wxCursor,
58903 _swigc__p_wxDC,
58904 _swigc__p_wxDateEvent,
58905 _swigc__p_wxDateTime,
58906 _swigc__p_wxDisplayChangedEvent,
58907 _swigc__p_wxDouble,
58908 _swigc__p_wxDropFilesEvent,
58909 _swigc__p_wxDuplexMode,
58910 _swigc__p_wxEraseEvent,
58911 _swigc__p_wxEvent,
58912 _swigc__p_wxEventLoop,
58913 _swigc__p_wxEventLoopActivator,
58914 _swigc__p_wxEvtHandler,
58915 _swigc__p_wxFSFile,
58916 _swigc__p_wxFileSystem,
58917 _swigc__p_wxFileSystemHandler,
58918 _swigc__p_wxFlexGridSizer,
58919 _swigc__p_wxFocusEvent,
58920 _swigc__p_wxFont,
58921 _swigc__p_wxFrame,
58922 _swigc__p_wxGBPosition,
58923 _swigc__p_wxGBSizerItem,
58924 _swigc__p_wxGBSpan,
58925 _swigc__p_wxGIFHandler,
58926 _swigc__p_wxGridBagSizer,
58927 _swigc__p_wxGridSizer,
58928 _swigc__p_wxHelpEvent__Origin,
58929 _swigc__p_wxICOHandler,
58930 _swigc__p_wxIconizeEvent,
58931 _swigc__p_wxIdleEvent,
58932 _swigc__p_wxImage,
58933 _swigc__p_wxImageHandler,
58934 _swigc__p_wxImageHistogram,
58935 _swigc__p_wxImage_HSVValue,
58936 _swigc__p_wxImage_RGBValue,
58937 _swigc__p_wxIndividualLayoutConstraint,
58938 _swigc__p_wxInitDialogEvent,
58939 _swigc__p_wxInputStream,
58940 _swigc__p_wxInternetFSHandler,
58941 _swigc__p_wxItemContainer,
58942 _swigc__p_wxJPEGHandler,
58943 _swigc__p_wxKeyEvent,
58944 _swigc__p_wxLayoutConstraints,
58945 _swigc__p_wxMaximizeEvent,
58946 _swigc__p_wxMemoryFSHandler,
58947 _swigc__p_wxMenu,
58948 _swigc__p_wxMenuBar,
58949 _swigc__p_wxMenuBarBase,
58950 _swigc__p_wxMenuEvent,
58951 _swigc__p_wxMenuItem,
58952 _swigc__p_wxMouseCaptureChangedEvent,
58953 _swigc__p_wxMouseCaptureLostEvent,
58954 _swigc__p_wxMouseEvent,
58955 _swigc__p_wxMoveEvent,
58956 _swigc__p_wxNavigationKeyEvent,
58957 _swigc__p_wxNcPaintEvent,
58958 _swigc__p_wxNotifyEvent,
58959 _swigc__p_wxObject,
58960 _swigc__p_wxOutputStream,
58961 _swigc__p_wxPCXHandler,
58962 _swigc__p_wxPNGHandler,
58963 _swigc__p_wxPNMHandler,
58964 _swigc__p_wxPaintEvent,
58965 _swigc__p_wxPaletteChangedEvent,
58966 _swigc__p_wxPaperSize,
58967 _swigc__p_wxPoint,
58968 _swigc__p_wxPoint2D,
58969 _swigc__p_wxPropagateOnce,
58970 _swigc__p_wxPropagationDisabler,
58971 _swigc__p_wxPyApp,
58972 _swigc__p_wxPyCommandEvent,
58973 _swigc__p_wxPyDropTarget,
58974 _swigc__p_wxPyEvent,
58975 _swigc__p_wxPyFileSystemHandler,
58976 _swigc__p_wxPyImageHandler,
58977 _swigc__p_wxPyInputStream,
58978 _swigc__p_wxPySizer,
58979 _swigc__p_wxPyValidator,
58980 _swigc__p_wxQuantize,
58981 _swigc__p_wxQueryNewPaletteEvent,
58982 _swigc__p_wxRealPoint,
58983 _swigc__p_wxRect,
58984 _swigc__p_wxRect2D,
58985 _swigc__p_wxRegion,
58986 _swigc__p_wxScrollEvent,
58987 _swigc__p_wxScrollWinEvent,
58988 _swigc__p_wxSetCursorEvent,
58989 _swigc__p_wxShowEvent,
58990 _swigc__p_wxSize,
58991 _swigc__p_wxSizeEvent,
58992 _swigc__p_wxSizer,
58993 _swigc__p_wxSizerItem,
58994 _swigc__p_wxStaticBox,
58995 _swigc__p_wxStaticBoxSizer,
58996 _swigc__p_wxStdDialogButtonSizer,
58997 _swigc__p_wxSysColourChangedEvent,
58998 _swigc__p_wxTGAHandler,
58999 _swigc__p_wxTIFFHandler,
59000 _swigc__p_wxToolTip,
59001 _swigc__p_wxUpdateUIEvent,
59002 _swigc__p_wxValidator,
59003 _swigc__p_wxVisualAttributes,
59004 _swigc__p_wxWindow,
59005 _swigc__p_wxWindowCreateEvent,
59006 _swigc__p_wxWindowDestroyEvent,
59007 _swigc__p_wxXPMHandler,
59008 _swigc__p_wxZipFSHandler,
59009 };
59010
59011
59012 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59013
59014 static swig_const_info swig_const_table[] = {
59015 {0, 0, 0, 0.0, 0, 0}};
59016
59017 #ifdef __cplusplus
59018 }
59019 #endif
59020 /* -----------------------------------------------------------------------------
59021 * Type initialization:
59022 * This problem is tough by the requirement that no dynamic
59023 * memory is used. Also, since swig_type_info structures store pointers to
59024 * swig_cast_info structures and swig_cast_info structures store pointers back
59025 * to swig_type_info structures, we need some lookup code at initialization.
59026 * The idea is that swig generates all the structures that are needed.
59027 * The runtime then collects these partially filled structures.
59028 * The SWIG_InitializeModule function takes these initial arrays out of
59029 * swig_module, and does all the lookup, filling in the swig_module.types
59030 * array with the correct data and linking the correct swig_cast_info
59031 * structures together.
59032 *
59033 * The generated swig_type_info structures are assigned staticly to an initial
59034 * array. We just loop though that array, and handle each type individually.
59035 * First we lookup if this type has been already loaded, and if so, use the
59036 * loaded structure instead of the generated one. Then we have to fill in the
59037 * cast linked list. The cast data is initially stored in something like a
59038 * two-dimensional array. Each row corresponds to a type (there are the same
59039 * number of rows as there are in the swig_type_initial array). Each entry in
59040 * a column is one of the swig_cast_info structures for that type.
59041 * The cast_initial array is actually an array of arrays, because each row has
59042 * a variable number of columns. So to actually build the cast linked list,
59043 * we find the array of casts associated with the type, and loop through it
59044 * adding the casts to the list. The one last trick we need to do is making
59045 * sure the type pointer in the swig_cast_info struct is correct.
59046 *
59047 * First off, we lookup the cast->type name to see if it is already loaded.
59048 * There are three cases to handle:
59049 * 1) If the cast->type has already been loaded AND the type we are adding
59050 * casting info to has not been loaded (it is in this module), THEN we
59051 * replace the cast->type pointer with the type pointer that has already
59052 * been loaded.
59053 * 2) If BOTH types (the one we are adding casting info to, and the
59054 * cast->type) are loaded, THEN the cast info has already been loaded by
59055 * the previous module so we just ignore it.
59056 * 3) Finally, if cast->type has not already been loaded, then we add that
59057 * swig_cast_info to the linked list (because the cast->type) pointer will
59058 * be correct.
59059 * ----------------------------------------------------------------------------- */
59060
59061 #ifdef __cplusplus
59062 extern "C" {
59063 #if 0
59064 } /* c-mode */
59065 #endif
59066 #endif
59067
59068 #if 0
59069 #define SWIGRUNTIME_DEBUG
59070 #endif
59071
59072 SWIGRUNTIME void
59073 SWIG_InitializeModule(void *clientdata) {
59074 size_t i;
59075 swig_module_info *module_head;
59076 static int init_run = 0;
59077
59078 clientdata = clientdata;
59079
59080 if (init_run) return;
59081 init_run = 1;
59082
59083 /* Initialize the swig_module */
59084 swig_module.type_initial = swig_type_initial;
59085 swig_module.cast_initial = swig_cast_initial;
59086
59087 /* Try and load any already created modules */
59088 module_head = SWIG_GetModule(clientdata);
59089 if (module_head) {
59090 swig_module.next = module_head->next;
59091 module_head->next = &swig_module;
59092 } else {
59093 /* This is the first module loaded */
59094 swig_module.next = &swig_module;
59095 SWIG_SetModule(clientdata, &swig_module);
59096 }
59097
59098 /* Now work on filling in swig_module.types */
59099 #ifdef SWIGRUNTIME_DEBUG
59100 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59101 #endif
59102 for (i = 0; i < swig_module.size; ++i) {
59103 swig_type_info *type = 0;
59104 swig_type_info *ret;
59105 swig_cast_info *cast;
59106
59107 #ifdef SWIGRUNTIME_DEBUG
59108 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59109 #endif
59110
59111 /* if there is another module already loaded */
59112 if (swig_module.next != &swig_module) {
59113 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59114 }
59115 if (type) {
59116 /* Overwrite clientdata field */
59117 #ifdef SWIGRUNTIME_DEBUG
59118 printf("SWIG_InitializeModule: found type %s\n", type->name);
59119 #endif
59120 if (swig_module.type_initial[i]->clientdata) {
59121 type->clientdata = swig_module.type_initial[i]->clientdata;
59122 #ifdef SWIGRUNTIME_DEBUG
59123 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59124 #endif
59125 }
59126 } else {
59127 type = swig_module.type_initial[i];
59128 }
59129
59130 /* Insert casting types */
59131 cast = swig_module.cast_initial[i];
59132 while (cast->type) {
59133 /* Don't need to add information already in the list */
59134 ret = 0;
59135 #ifdef SWIGRUNTIME_DEBUG
59136 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59137 #endif
59138 if (swig_module.next != &swig_module) {
59139 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59140 #ifdef SWIGRUNTIME_DEBUG
59141 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59142 #endif
59143 }
59144 if (ret) {
59145 if (type == swig_module.type_initial[i]) {
59146 #ifdef SWIGRUNTIME_DEBUG
59147 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59148 #endif
59149 cast->type = ret;
59150 ret = 0;
59151 } else {
59152 /* Check for casting already in the list */
59153 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59154 #ifdef SWIGRUNTIME_DEBUG
59155 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59156 #endif
59157 if (!ocast) ret = 0;
59158 }
59159 }
59160
59161 if (!ret) {
59162 #ifdef SWIGRUNTIME_DEBUG
59163 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59164 #endif
59165 if (type->cast) {
59166 type->cast->prev = cast;
59167 cast->next = type->cast;
59168 }
59169 type->cast = cast;
59170 }
59171 cast++;
59172 }
59173 /* Set entry in modules->types array equal to the type */
59174 swig_module.types[i] = type;
59175 }
59176 swig_module.types[i] = 0;
59177
59178 #ifdef SWIGRUNTIME_DEBUG
59179 printf("**** SWIG_InitializeModule: Cast List ******\n");
59180 for (i = 0; i < swig_module.size; ++i) {
59181 int j = 0;
59182 swig_cast_info *cast = swig_module.cast_initial[i];
59183 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59184 while (cast->type) {
59185 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59186 cast++;
59187 ++j;
59188 }
59189 printf("---- Total casts: %d\n",j);
59190 }
59191 printf("**** SWIG_InitializeModule: Cast List ******\n");
59192 #endif
59193 }
59194
59195 /* This function will propagate the clientdata field of type to
59196 * any new swig_type_info structures that have been added into the list
59197 * of equivalent types. It is like calling
59198 * SWIG_TypeClientData(type, clientdata) a second time.
59199 */
59200 SWIGRUNTIME void
59201 SWIG_PropagateClientData(void) {
59202 size_t i;
59203 swig_cast_info *equiv;
59204 static int init_run = 0;
59205
59206 if (init_run) return;
59207 init_run = 1;
59208
59209 for (i = 0; i < swig_module.size; i++) {
59210 if (swig_module.types[i]->clientdata) {
59211 equiv = swig_module.types[i]->cast;
59212 while (equiv) {
59213 if (!equiv->converter) {
59214 if (equiv->type && !equiv->type->clientdata)
59215 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59216 }
59217 equiv = equiv->next;
59218 }
59219 }
59220 }
59221 }
59222
59223 #ifdef __cplusplus
59224 #if 0
59225 {
59226 /* c-mode */
59227 #endif
59228 }
59229 #endif
59230
59231
59232
59233 #ifdef __cplusplus
59234 extern "C" {
59235 #endif
59236
59237 /* Python-specific SWIG API */
59238 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59239 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59240 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59241
59242 /* -----------------------------------------------------------------------------
59243 * global variable support code.
59244 * ----------------------------------------------------------------------------- */
59245
59246 typedef struct swig_globalvar {
59247 char *name; /* Name of global variable */
59248 PyObject *(*get_attr)(void); /* Return the current value */
59249 int (*set_attr)(PyObject *); /* Set the value */
59250 struct swig_globalvar *next;
59251 } swig_globalvar;
59252
59253 typedef struct swig_varlinkobject {
59254 PyObject_HEAD
59255 swig_globalvar *vars;
59256 } swig_varlinkobject;
59257
59258 SWIGINTERN PyObject *
59259 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59260 return PyString_FromString("<Swig global variables>");
59261 }
59262
59263 SWIGINTERN PyObject *
59264 swig_varlink_str(swig_varlinkobject *v) {
59265 PyObject *str = PyString_FromString("(");
59266 swig_globalvar *var;
59267 for (var = v->vars; var; var=var->next) {
59268 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59269 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59270 }
59271 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59272 return str;
59273 }
59274
59275 SWIGINTERN int
59276 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59277 PyObject *str = swig_varlink_str(v);
59278 fprintf(fp,"Swig global variables ");
59279 fprintf(fp,"%s\n", PyString_AsString(str));
59280 Py_DECREF(str);
59281 return 0;
59282 }
59283
59284 SWIGINTERN void
59285 swig_varlink_dealloc(swig_varlinkobject *v) {
59286 swig_globalvar *var = v->vars;
59287 while (var) {
59288 swig_globalvar *n = var->next;
59289 free(var->name);
59290 free(var);
59291 var = n;
59292 }
59293 }
59294
59295 SWIGINTERN PyObject *
59296 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59297 PyObject *res = NULL;
59298 swig_globalvar *var = v->vars;
59299 while (var) {
59300 if (strcmp(var->name,n) == 0) {
59301 res = (*var->get_attr)();
59302 break;
59303 }
59304 var = var->next;
59305 }
59306 if (res == NULL && !PyErr_Occurred()) {
59307 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59308 }
59309 return res;
59310 }
59311
59312 SWIGINTERN int
59313 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59314 int res = 1;
59315 swig_globalvar *var = v->vars;
59316 while (var) {
59317 if (strcmp(var->name,n) == 0) {
59318 res = (*var->set_attr)(p);
59319 break;
59320 }
59321 var = var->next;
59322 }
59323 if (res == 1 && !PyErr_Occurred()) {
59324 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59325 }
59326 return res;
59327 }
59328
59329 SWIGINTERN PyTypeObject*
59330 swig_varlink_type(void) {
59331 static char varlink__doc__[] = "Swig var link object";
59332 static PyTypeObject varlink_type;
59333 static int type_init = 0;
59334 if (!type_init) {
59335 const PyTypeObject tmp
59336 = {
59337 PyObject_HEAD_INIT(NULL)
59338 0, /* Number of items in variable part (ob_size) */
59339 (char *)"swigvarlink", /* Type name (tp_name) */
59340 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59341 0, /* Itemsize (tp_itemsize) */
59342 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59343 (printfunc) swig_varlink_print, /* Print (tp_print) */
59344 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59345 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59346 0, /* tp_compare */
59347 (reprfunc) swig_varlink_repr, /* tp_repr */
59348 0, /* tp_as_number */
59349 0, /* tp_as_sequence */
59350 0, /* tp_as_mapping */
59351 0, /* tp_hash */
59352 0, /* tp_call */
59353 (reprfunc)swig_varlink_str, /* tp_str */
59354 0, /* tp_getattro */
59355 0, /* tp_setattro */
59356 0, /* tp_as_buffer */
59357 0, /* tp_flags */
59358 varlink__doc__, /* tp_doc */
59359 0, /* tp_traverse */
59360 0, /* tp_clear */
59361 0, /* tp_richcompare */
59362 0, /* tp_weaklistoffset */
59363 #if PY_VERSION_HEX >= 0x02020000
59364 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59365 #endif
59366 #if PY_VERSION_HEX >= 0x02030000
59367 0, /* tp_del */
59368 #endif
59369 #ifdef COUNT_ALLOCS
59370 0,0,0,0 /* tp_alloc -> tp_next */
59371 #endif
59372 };
59373 varlink_type = tmp;
59374 varlink_type.ob_type = &PyType_Type;
59375 type_init = 1;
59376 }
59377 return &varlink_type;
59378 }
59379
59380 /* Create a variable linking object for use later */
59381 SWIGINTERN PyObject *
59382 SWIG_Python_newvarlink(void) {
59383 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59384 if (result) {
59385 result->vars = 0;
59386 }
59387 return ((PyObject*) result);
59388 }
59389
59390 SWIGINTERN void
59391 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59392 swig_varlinkobject *v = (swig_varlinkobject *) p;
59393 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59394 if (gv) {
59395 size_t size = strlen(name)+1;
59396 gv->name = (char *)malloc(size);
59397 if (gv->name) {
59398 strncpy(gv->name,name,size);
59399 gv->get_attr = get_attr;
59400 gv->set_attr = set_attr;
59401 gv->next = v->vars;
59402 }
59403 }
59404 v->vars = gv;
59405 }
59406
59407 SWIGINTERN PyObject *
59408 SWIG_globals() {
59409 static PyObject *_SWIG_globals = 0;
59410 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59411 return _SWIG_globals;
59412 }
59413
59414 /* -----------------------------------------------------------------------------
59415 * constants/methods manipulation
59416 * ----------------------------------------------------------------------------- */
59417
59418 /* Install Constants */
59419 SWIGINTERN void
59420 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59421 PyObject *obj = 0;
59422 size_t i;
59423 for (i = 0; constants[i].type; ++i) {
59424 switch(constants[i].type) {
59425 case SWIG_PY_POINTER:
59426 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59427 break;
59428 case SWIG_PY_BINARY:
59429 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59430 break;
59431 default:
59432 obj = 0;
59433 break;
59434 }
59435 if (obj) {
59436 PyDict_SetItemString(d, constants[i].name, obj);
59437 Py_DECREF(obj);
59438 }
59439 }
59440 }
59441
59442 /* -----------------------------------------------------------------------------*/
59443 /* Fix SwigMethods to carry the callback ptrs when needed */
59444 /* -----------------------------------------------------------------------------*/
59445
59446 SWIGINTERN void
59447 SWIG_Python_FixMethods(PyMethodDef *methods,
59448 swig_const_info *const_table,
59449 swig_type_info **types,
59450 swig_type_info **types_initial) {
59451 size_t i;
59452 for (i = 0; methods[i].ml_name; ++i) {
59453 const char *c = methods[i].ml_doc;
59454 if (c && (c = strstr(c, "swig_ptr: "))) {
59455 int j;
59456 swig_const_info *ci = 0;
59457 const char *name = c + 10;
59458 for (j = 0; const_table[j].type; ++j) {
59459 if (strncmp(const_table[j].name, name,
59460 strlen(const_table[j].name)) == 0) {
59461 ci = &(const_table[j]);
59462 break;
59463 }
59464 }
59465 if (ci) {
59466 size_t shift = (ci->ptype) - types;
59467 swig_type_info *ty = types_initial[shift];
59468 size_t ldoc = (c - methods[i].ml_doc);
59469 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59470 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59471 if (ndoc) {
59472 char *buff = ndoc;
59473 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59474 if (ptr) {
59475 strncpy(buff, methods[i].ml_doc, ldoc);
59476 buff += ldoc;
59477 strncpy(buff, "swig_ptr: ", 10);
59478 buff += 10;
59479 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59480 methods[i].ml_doc = ndoc;
59481 }
59482 }
59483 }
59484 }
59485 }
59486 }
59487
59488 #ifdef __cplusplus
59489 }
59490 #endif
59491
59492 /* -----------------------------------------------------------------------------*
59493 * Partial Init method
59494 * -----------------------------------------------------------------------------*/
59495
59496 #ifdef __cplusplus
59497 extern "C"
59498 #endif
59499 SWIGEXPORT void SWIG_init(void) {
59500 PyObject *m, *d;
59501
59502 /* Fix SwigMethods to carry the callback ptrs when needed */
59503 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59504
59505 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59506 d = PyModule_GetDict(m);
59507
59508 SWIG_InitializeModule(0);
59509 SWIG_InstallConstants(d,swig_const_table);
59510
59511
59512
59513 #ifndef wxPyUSE_EXPORT
59514 // Make our API structure a CObject so other modules can import it
59515 // from this module.
59516 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59517 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59518 Py_XDECREF(cobj);
59519 #endif
59520
59521 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59522 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59523 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59524 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59525 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59526 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59527 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59528 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59529 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59530 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59531 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59532 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59533 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59534 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59535 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59536 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59537 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59538 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59539 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59540 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59541 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59542 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59543 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59544 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59545 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59546 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59547 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59548 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59549 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59550 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59551 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59552 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59553 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59554 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59555 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59556 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59557 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59558 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59559 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59560 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59561 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59562 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59563 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59564 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59565 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59566 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59567 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59568 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59569 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59570 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59571 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59572 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59573 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59574 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59575 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59576 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59577 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59578 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59579 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59580 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59581 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59582 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59583 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59584 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59585 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59586 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59587 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59588 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59589 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59590 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59591 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59592 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59593 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59594 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59595 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59596 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59597 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59598 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59599 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59600 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59601 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59602 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59603 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59604 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59605 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59606 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59607 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59608 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59609 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59610 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59611 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59612 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59613 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59614 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59615 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59616 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59617 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59618 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59619 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59620 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59621 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59622 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59623 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59624 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59625 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59626 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59627 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59628 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59629 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59630 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59631 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59632 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59633 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59634 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59635 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59636 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59637 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59638 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59639 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59640 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59641 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59642 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59643 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59644 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59645 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59646 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59647 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59648 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59649 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59650 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59651 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59652 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59653 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59654 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59655 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59656 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59657 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59658 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59659 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59660 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59661 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59662 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59663 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59664 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59665 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59666 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59667 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59668 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59669 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59670 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59671 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59672 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59673 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59674 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59675 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59676 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59677 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59678 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59679 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59680 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59681 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59682 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59683 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59684 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59685 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59686 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59687 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59688 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59689 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59690 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59691 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59692 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59693 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59694 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59695 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59696 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59697 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59698 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59699 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59700 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59701 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59702 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59703 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59704 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59705 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59706 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59707 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59708 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59709 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59710 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59711 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59712 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59713 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59714 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59715 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59716 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59717 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59718 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59719 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59720 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59721 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59722 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59723 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59724 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59725 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59726 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59727 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59728 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59729 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59730 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59731 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59732 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59733 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59734 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59735 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59736 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59737 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59738 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59739 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59740 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59741 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59742 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59743 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59744 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59745 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59746 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59747 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59748 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59749 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59750 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59751 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59752 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59753 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59754 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59755 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59756 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59757 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59758 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59759 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59760 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59761 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59762 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59763 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59764 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59765 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59766 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59767 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59768 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59769 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59770 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59771 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59772 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59773 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59774 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59775 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59776 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59777 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59778 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59779 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59780 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59781 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59782 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59783 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59784 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59785 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59786 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59787 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59788 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59789 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59790 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59791 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59792 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59793 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59794 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59795 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59796 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59797 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59798 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59799 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59800 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59801 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59802 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59803 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59804 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59805 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59806 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59807 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59808 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59809 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59810 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59811 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59812 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59813 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59814 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59815 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59816 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59817 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59818 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59819 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59820 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59821 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59822 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59823 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59824 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59825 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59826 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59827 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59828 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59829 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59830 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59831 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59832 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59833 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59834 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59835 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59836 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59837 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59838 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59839 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59840 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59841 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59842 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59843 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59844 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59845 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59846 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59847 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59848 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59849 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59850 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59851 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59852 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59853 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59854 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59855 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59856 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59857 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59858 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59859 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59860 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59861 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59862 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59863 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59864 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59865 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59866 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59867 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59868 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59869 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59870 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59871 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59872 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59873 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59874 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59875 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59876 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59877 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59878 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59879 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59880 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59881 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59882 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59883 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59884 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59885 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59886 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59887 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59888 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59889 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59890 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59891 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59892 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59893 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59894 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59895 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59896 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59897 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59898 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59899 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59900 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59901 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59902 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59903 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59904 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59905 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59906 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59907 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59908 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59909 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59910 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59911 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59912 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59913 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59914 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59915 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59916 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59917 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59918 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59919 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59920 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59921 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59922 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59923 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59924 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59925 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59926 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59927 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59928 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59929 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59930 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59931 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59932 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59933 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59934 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59935 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59936 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59937 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59938 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59939 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59940 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59941 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59942 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59943 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59944 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59945 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59946 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59947 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59948 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59949 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59950 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59951 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59952 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59953 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59954 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59955 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59956 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59957 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59958 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59959 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59960 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59961 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59962 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59963 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59964 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59965 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59966 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59967 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59968 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59969 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59970 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
59971 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
59972 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
59973 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
59974 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
59975 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
59976 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
59977 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
59978 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
59979 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
59980 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
59981 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
59982 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
59983 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
59984 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
59985 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
59986 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
59987 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
59988 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
59989 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
59990 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
59991 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
59992 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
59993 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
59994 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
59995 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
59996 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
59997 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
59998 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
59999 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60000 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60001 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60002 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60003 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60004 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60005 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60006 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60007 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60008 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60009 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60010 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60011 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60012 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60013 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60014 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60015 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60016 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60017 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60018 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60019 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60020 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60021 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60022 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60023 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60024 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60025 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60026 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60027 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60028 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60029 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60030 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60031 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60032 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60033 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60034 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60035 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60036 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60037 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60038 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60039 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60040 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60041 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60042 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60043 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60044 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60045 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60046 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60047 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60048 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60049 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60050 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60051 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60052 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60053 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60054 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60055 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60056 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60057 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60058 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60059 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60060 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60061 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60062 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60063 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60064 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60065 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60066 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60067 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60068 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60069 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60070 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60071 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60072 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60073 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60074 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60075 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60076 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60077 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60078 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60079 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60080 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60081 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60082 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60083 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60084 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60085 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60086 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60087 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60088 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60089 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60090 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60091 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60092 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60093 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60094 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60095 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60096 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60097 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60098 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60099 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60100 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60101 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60102 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60103 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60104 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60105 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60106 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60107 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60108 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60109 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60110 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60111 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60112 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60113 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60114 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60115 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60116 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60117 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60118 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60119 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60120 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60121 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60122 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60123 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60124 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60125 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60126 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60127 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60128 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60129 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60130 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60131 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60132 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60133 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60134 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60135 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60136 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60137 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60138 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60139 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60140 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60141 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60142 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60143 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60144 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60145 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60146 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60147 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60148 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60149 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60150 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60151 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60152 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60153 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60154 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60155 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60156 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60157 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60158 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60159 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60160 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60161 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60162 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60163 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60164 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60165 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60166 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60167 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60168 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60169 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60170 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60171 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60172 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60173 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60174 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60175 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60176 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60177 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60178 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60179 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60180 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60181 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60182 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60183 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60184 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60185 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60186
60187 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60188
60189
60190 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60191
60192 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60193 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60194 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60195 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60196 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60197 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60198 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60199 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60200 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60201 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60202 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60203 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60204 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60205 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60206 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60207 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60208 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60209 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60210 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60211 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60212 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60213 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60214 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60215 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60216 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60217 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60218 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60219 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60220 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60221 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60222 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60223 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60224 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60225 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60226 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60227 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60228 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60229 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60230 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60231 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60232 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60233 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60234 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60235 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60236 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60237 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60238 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60239 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60240 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60241 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60242 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60243 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60244 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60245 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60246 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60247 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60248 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60249 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60250 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60251 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60252 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60253 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60254 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60255 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60256 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60257 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60258 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60259 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60260 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60261 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60262 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60263 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60264 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60265 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60266 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60267 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60268 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60269 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60270 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60271 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60272 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60273 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60274 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60275 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60276 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60277 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60278 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60279 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60280 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60281 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60282 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60283 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60284 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60285 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60286 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60287 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60288 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60289 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60290 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60291 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60292 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60293 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60294 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60295 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60296 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60297 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60298 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60299 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60300 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60301 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60302 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60303 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60304 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60305 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60306 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60307 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60308 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60309 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60310 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60311 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60312 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60313 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60314 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60315 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60316 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60317 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60318 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60319 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60320 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60321 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60322 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60323 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60324 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60325 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60326 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60327 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60328 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60329 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60330 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60331 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60332 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60333 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60334 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60335 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60336 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60337 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60338 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60339 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60340 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60341 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60342 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60343 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60344 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60345 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60346 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60347 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60348 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60349 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60350 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60351 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60352 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60353 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60354 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60355 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60356 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60357 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60358 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60359 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60360 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60361 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60362 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60363 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60364 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60365 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60366 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60367 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60368 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60369 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60370 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60371 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60372 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60373 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60374 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60375 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60376 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60377 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60378 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60379 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60380 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60381 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60382 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60383 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60384 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60385 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60386 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60387 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60388 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60389 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60390 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60391 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60392 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60393 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60394 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60395 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60396 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60397 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60398 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60399 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60400 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60401 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60402 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60403 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60404 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60405 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60406
60407 // Initialize threading, some globals and such
60408 __wxPyPreStart(d);
60409
60410
60411 // Although these are defined in __version__ they need to be here too so
60412 // that an assert can be done to ensure that the wxPython and the wxWindows
60413 // versions match.
60414 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60415 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60416 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60417
60418 }
60419
wxWidgets (Impactor)