]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Forward port recent changes on the 2.8 branch to HEAD
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventBlocker swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoop swig_types[39]
2506 #define SWIGTYPE_p_wxEventLoopActivator swig_types[40]
2507 #define SWIGTYPE_p_wxEvtHandler swig_types[41]
2508 #define SWIGTYPE_p_wxFSFile swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystem swig_types[43]
2510 #define SWIGTYPE_p_wxFileSystemHandler swig_types[44]
2511 #define SWIGTYPE_p_wxFlexGridSizer swig_types[45]
2512 #define SWIGTYPE_p_wxFocusEvent swig_types[46]
2513 #define SWIGTYPE_p_wxFont swig_types[47]
2514 #define SWIGTYPE_p_wxFrame swig_types[48]
2515 #define SWIGTYPE_p_wxGBPosition swig_types[49]
2516 #define SWIGTYPE_p_wxGBSizerItem swig_types[50]
2517 #define SWIGTYPE_p_wxGBSpan swig_types[51]
2518 #define SWIGTYPE_p_wxGIFHandler swig_types[52]
2519 #define SWIGTYPE_p_wxGridBagSizer swig_types[53]
2520 #define SWIGTYPE_p_wxGridSizer swig_types[54]
2521 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[55]
2522 #define SWIGTYPE_p_wxICOHandler swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageHistogram swig_types[61]
2528 #define SWIGTYPE_p_wxImage_HSVValue swig_types[62]
2529 #define SWIGTYPE_p_wxImage_RGBValue swig_types[63]
2530 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[64]
2531 #define SWIGTYPE_p_wxInitDialogEvent swig_types[65]
2532 #define SWIGTYPE_p_wxInputStream swig_types[66]
2533 #define SWIGTYPE_p_wxInternetFSHandler swig_types[67]
2534 #define SWIGTYPE_p_wxItemContainer swig_types[68]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[69]
2536 #define SWIGTYPE_p_wxKeyEvent swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxMaximizeEvent swig_types[72]
2539 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
2540 #define SWIGTYPE_p_wxMenu swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBar swig_types[75]
2542 #define SWIGTYPE_p_wxMenuBarBase swig_types[76]
2543 #define SWIGTYPE_p_wxMenuEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMenuItem swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMouseEvent swig_types[81]
2548 #define SWIGTYPE_p_wxMoveEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNcPaintEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNotifyEvent swig_types[85]
2552 #define SWIGTYPE_p_wxObject swig_types[86]
2553 #define SWIGTYPE_p_wxOutputStream swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2560 #define SWIGTYPE_p_wxPoint swig_types[94]
2561 #define SWIGTYPE_p_wxPoint2D swig_types[95]
2562 #define SWIGTYPE_p_wxPosition swig_types[96]
2563 #define SWIGTYPE_p_wxPropagateOnce swig_types[97]
2564 #define SWIGTYPE_p_wxPropagationDisabler swig_types[98]
2565 #define SWIGTYPE_p_wxPyApp swig_types[99]
2566 #define SWIGTYPE_p_wxPyCommandEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyDropTarget swig_types[101]
2568 #define SWIGTYPE_p_wxPyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyImageHandler swig_types[104]
2571 #define SWIGTYPE_p_wxPyInputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPySizer swig_types[106]
2573 #define SWIGTYPE_p_wxPyValidator swig_types[107]
2574 #define SWIGTYPE_p_wxQuantize swig_types[108]
2575 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[109]
2576 #define SWIGTYPE_p_wxRealPoint swig_types[110]
2577 #define SWIGTYPE_p_wxRect swig_types[111]
2578 #define SWIGTYPE_p_wxRect2D swig_types[112]
2579 #define SWIGTYPE_p_wxRegion swig_types[113]
2580 #define SWIGTYPE_p_wxScrollEvent swig_types[114]
2581 #define SWIGTYPE_p_wxScrollWinEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSetCursorEvent swig_types[116]
2583 #define SWIGTYPE_p_wxShowEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSize swig_types[118]
2585 #define SWIGTYPE_p_wxSizeEvent swig_types[119]
2586 #define SWIGTYPE_p_wxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSizerFlags swig_types[121]
2588 #define SWIGTYPE_p_wxSizerItem swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBox swig_types[123]
2590 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[124]
2591 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[125]
2592 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[126]
2593 #define SWIGTYPE_p_wxTGAHandler swig_types[127]
2594 #define SWIGTYPE_p_wxTIFFHandler swig_types[128]
2595 #define SWIGTYPE_p_wxToolTip swig_types[129]
2596 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[130]
2597 #define SWIGTYPE_p_wxValidator swig_types[131]
2598 #define SWIGTYPE_p_wxVisualAttributes swig_types[132]
2599 #define SWIGTYPE_p_wxWindow swig_types[133]
2600 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[134]
2601 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[135]
2602 #define SWIGTYPE_p_wxXPMHandler swig_types[136]
2603 #define SWIGTYPE_p_wxZipFSHandler swig_types[137]
2604 static swig_type_info *swig_types[139];
2605 static swig_module_info swig_module = {swig_types, 138, 0, 0, 0, 0};
2606 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2607 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2608
2609 /* -------- TYPES TABLE (END) -------- */
2610
2611 #if (PY_VERSION_HEX <= 0x02000000)
2612 # if !defined(SWIG_PYTHON_CLASSIC)
2613 # error "This python version requires to use swig with the '-classic' option"
2614 # endif
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodern' option"
2618 #endif
2619 #if (PY_VERSION_HEX <= 0x02020000)
2620 # error "This python version requires to use swig with the '-nomodernargs' option"
2621 #endif
2622 #ifndef METH_O
2623 # error "This python version requires to use swig with the '-nofastunpack' option"
2624 #endif
2625
2626 /*-----------------------------------------------
2627 @(target):= _core_.so
2628 ------------------------------------------------*/
2629 #define SWIG_init init_core_
2630
2631 #define SWIG_name "_core_"
2632
2633 #define SWIGVERSION 0x010329
2634
2635
2636 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2637 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2638
2639
2640 #include <stdexcept>
2641
2642
2643 namespace swig {
2644 class PyObject_ptr {
2645 protected:
2646 PyObject *_obj;
2647
2648 public:
2649 PyObject_ptr() :_obj(0)
2650 {
2651 }
2652
2653 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2654 {
2655 Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2659 {
2660 if (initial_ref) Py_XINCREF(_obj);
2661 }
2662
2663 PyObject_ptr & operator=(const PyObject_ptr& item)
2664 {
2665 Py_XINCREF(item._obj);
2666 Py_XDECREF(_obj);
2667 _obj = item._obj;
2668 return *this;
2669 }
2670
2671 ~PyObject_ptr()
2672 {
2673 Py_XDECREF(_obj);
2674 }
2675
2676 operator PyObject *() const
2677 {
2678 return _obj;
2679 }
2680
2681 PyObject *operator->() const
2682 {
2683 return _obj;
2684 }
2685 };
2686 }
2687
2688
2689 namespace swig {
2690 struct PyObject_var : PyObject_ptr {
2691 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2692
2693 PyObject_var & operator = (PyObject* obj)
2694 {
2695 Py_XDECREF(_obj);
2696 _obj = obj;
2697 return *this;
2698 }
2699 };
2700 }
2701
2702
2703 #include "wx/wxPython/wxPython_int.h"
2704 #include "wx/wxPython/pyclasses.h"
2705 #include "wx/wxPython/twoitem.h"
2706
2707
2708 #ifndef wxPyUSE_EXPORT
2709 // Helper functions for dealing with SWIG objects and such. These are
2710 // located here so they know about the SWIG types and functions declared
2711 // in the wrapper code.
2712
2713 #include <wx/hashmap.h>
2714 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2715
2716
2717 // Maintains a hashmap of className to swig_type_info pointers. Given the
2718 // name of a class either looks up the type info in the cache, or scans the
2719 // SWIG tables for it.
2720 extern PyObject* wxPyPtrTypeMap;
2721 static
2722 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2723
2724 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2725
2726 if (typeInfoCache == NULL)
2727 typeInfoCache = new wxPyTypeInfoHashMap;
2728
2729 wxString name(className);
2730 swig_type_info* swigType = (*typeInfoCache)[name];
2731
2732 if (! swigType) {
2733 // it wasn't in the cache, so look it up from SWIG
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736
2737 // if it still wasn't found, try looking for a mapped name
2738 if (!swigType) {
2739 PyObject* item;
2740 name = className;
2741
2742 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2743 (char*)(const char*)name.mbc_str())) != NULL) {
2744 name = wxString(PyString_AsString(item), *wxConvCurrent);
2745 name.Append(wxT(" *"));
2746 swigType = SWIG_TypeQuery(name.mb_str());
2747 }
2748 }
2749 if (swigType) {
2750 // and add it to the map if found
2751 (*typeInfoCache)[className] = swigType;
2752 }
2753 }
2754 return swigType;
2755 }
2756
2757
2758 // Check if a class name is a type known to SWIG
2759 bool wxPyCheckSwigType(const wxChar* className) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 return swigType != NULL;
2763 }
2764
2765
2766 // Given a pointer to a C++ object and a class name, construct a Python proxy
2767 // object for it.
2768 PyObject* wxPyConstructObject(void* ptr,
2769 const wxChar* className,
2770 int setThisOwn) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2774
2775 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2776 }
2777
2778
2779 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2780 // Ensures that the proxy object is of the specified (or derived) type. If
2781 // not able to perform the conversion then a Python exception is set and the
2782 // error should be handled properly in the caller. Returns True on success.
2783 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2784 const wxChar* className) {
2785
2786 swig_type_info* swigType = wxPyFindSwigType(className);
2787 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2788
2789 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2790 }
2791
2792
2793
2794 // Make a SWIGified pointer object suitable for a .this attribute
2795 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2796
2797 PyObject* robj = NULL;
2798
2799 swig_type_info* swigType = wxPyFindSwigType(className);
2800 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2801
2802 robj = PySwigObject_New(ptr, swigType, 0);
2803 return robj;
2804 }
2805
2806
2807 // Python's PyInstance_Check does not return True for instances of new-style
2808 // classes. This should get close enough for both new and old classes but I
2809 // should re-evaluate the need for doing instance checks...
2810 bool wxPyInstance_Check(PyObject* obj) {
2811 return PyObject_HasAttrString(obj, "__class__") != 0;
2812 }
2813
2814
2815 // This one checks if the object is an instance of a SWIG proxy class (it has
2816 // a .this attribute, and the .this attribute is a PySwigObject.)
2817 bool wxPySwigInstance_Check(PyObject* obj) {
2818 static PyObject* this_str = NULL;
2819 if (this_str == NULL)
2820 this_str = PyString_FromString("this");
2821
2822 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2823 if (this_attr) {
2824 bool retval = (PySwigObject_Check(this_attr) != 0);
2825 Py_DECREF(this_attr);
2826 return retval;
2827 }
2828
2829 PyErr_Clear();
2830 return false;
2831 }
2832
2833
2834 // Export a C API in a struct. Other modules will be able to load this from
2835 // the wx._core_ module and will then have safe access to these functions,
2836 // even if they are located in another shared library.
2837 static wxPyCoreAPI API = {
2838
2839 wxPyCheckSwigType,
2840 wxPyConstructObject,
2841 wxPyConvertSwigPtr,
2842 wxPyMakeSwigPtr,
2843
2844 wxPyBeginAllowThreads,
2845 wxPyEndAllowThreads,
2846 wxPyBeginBlockThreads,
2847 wxPyEndBlockThreads,
2848
2849 wxPy_ConvertList,
2850
2851 wxString_in_helper,
2852 Py2wxString,
2853 wx2PyString,
2854
2855 byte_LIST_helper,
2856 int_LIST_helper,
2857 long_LIST_helper,
2858 string_LIST_helper,
2859 wxPoint_LIST_helper,
2860 wxBitmap_LIST_helper,
2861 wxString_LIST_helper,
2862 wxAcceleratorEntry_LIST_helper,
2863
2864 wxSize_helper,
2865 wxPoint_helper,
2866 wxRealPoint_helper,
2867 wxRect_helper,
2868 wxColour_helper,
2869 wxPoint2D_helper,
2870
2871 wxPySimple_typecheck,
2872 wxColour_typecheck,
2873
2874 wxPyCBH_setCallbackInfo,
2875 wxPyCBH_findCallback,
2876 wxPyCBH_callCallback,
2877 wxPyCBH_callCallbackObj,
2878 wxPyCBH_delete,
2879
2880 wxPyMake_wxObject,
2881 wxPyMake_wxSizer,
2882 wxPyPtrTypeMap_Add,
2883 wxPy2int_seq_helper,
2884 wxPy4int_seq_helper,
2885 wxArrayString2PyList_helper,
2886 wxArrayInt2PyList_helper,
2887
2888 wxPyClientData_dtor,
2889 wxPyUserData_dtor,
2890 wxPyOORClientData_dtor,
2891
2892 wxPyCBInputStream_create,
2893 wxPyCBInputStream_copy,
2894
2895 wxPyInstance_Check,
2896 wxPySwigInstance_Check,
2897
2898 wxPyCheckForApp,
2899
2900 wxArrayDouble2PyList_helper,
2901 wxPoint2D_LIST_helper,
2902 wxRect2D_helper,
2903 wxPosition_helper,
2904
2905 };
2906
2907 #endif
2908
2909
2910 #if !WXWIN_COMPATIBILITY_2_4
2911 #define wxHIDE_READONLY 0
2912 #endif
2913
2914
2915 #define SWIG_From_long PyInt_FromLong
2916
2917
2918 SWIGINTERNINLINE PyObject *
2919 SWIG_From_int (int value)
2920 {
2921 return SWIG_From_long (value);
2922 }
2923
2924 static const wxString wxPyEmptyString(wxEmptyString);
2925 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2926 return self->GetClassInfo()->GetClassName();
2927 }
2928 SWIGINTERN void wxObject_Destroy(wxObject *self){
2929 delete self;
2930 }
2931
2932 #ifndef __WXMAC__
2933 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2934 #endif
2935
2936
2937 #include <limits.h>
2938 #ifndef LLONG_MIN
2939 # define LLONG_MIN LONG_LONG_MIN
2940 #endif
2941 #ifndef LLONG_MAX
2942 # define LLONG_MAX LONG_LONG_MAX
2943 #endif
2944 #ifndef ULLONG_MAX
2945 # define ULLONG_MAX ULONG_LONG_MAX
2946 #endif
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_long (PyObject* obj, long* val)
2951 {
2952 if (PyNumber_Check(obj)) {
2953 if (val) *val = PyInt_AsLong(obj);
2954 return SWIG_OK;
2955 }
2956 return SWIG_TypeError;
2957 }
2958
2959
2960 SWIGINTERN int
2961 SWIG_AsVal_int (PyObject * obj, int *val)
2962 {
2963 long v;
2964 int res = SWIG_AsVal_long (obj, &v);
2965 if (SWIG_IsOK(res)) {
2966 if ((v < INT_MIN || v > INT_MAX)) {
2967 return SWIG_OverflowError;
2968 } else {
2969 if (val) *val = static_cast< int >(v);
2970 }
2971 }
2972 return res;
2973 }
2974
2975 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return false;
2978 if ( ! wxSize_helper(other, &obj) ) {
2979 PyErr_Clear();
2980 return false;
2981 }
2982 return self->operator==(*obj);
2983 }
2984 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2985 wxSize temp, *obj = &temp;
2986 if ( other == Py_None ) return true;
2987 if ( ! wxSize_helper(other, &obj)) {
2988 PyErr_Clear();
2989 return true;
2990 }
2991 return self->operator!=(*obj);
2992 }
2993
2994 #include <float.h>
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_double (PyObject *obj, double* val)
2999 {
3000 if (PyNumber_Check(obj)) {
3001 if (val) *val = PyFloat_AsDouble(obj);
3002 return SWIG_OK;
3003 }
3004 return SWIG_TypeError;
3005 }
3006
3007
3008 SWIGINTERN int
3009 SWIG_AsVal_float (PyObject * obj, float *val)
3010 {
3011 double v;
3012 int res = SWIG_AsVal_double (obj, &v);
3013 if (SWIG_IsOK(res)) {
3014 if ((v < -FLT_MAX || v > FLT_MAX)) {
3015 return SWIG_OverflowError;
3016 } else {
3017 if (val) *val = static_cast< float >(v);
3018 }
3019 }
3020 return res;
3021 }
3022
3023 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3024 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3025 PyObject* tup = PyTuple_New(2);
3026 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3027 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3028 //wxPyEndBlockThreads(blocked);
3029 return tup;
3030 }
3031
3032 #define SWIG_From_double PyFloat_FromDouble
3033
3034 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return false;
3037 if ( ! wxRealPoint_helper(other, &obj) ) {
3038 PyErr_Clear();
3039 return false;
3040 }
3041 return self->operator==(*obj);
3042 }
3043 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3044 wxRealPoint temp, *obj = &temp;
3045 if ( other == Py_None ) return true;
3046 if ( ! wxRealPoint_helper(other, &obj)) {
3047 PyErr_Clear();
3048 return true;
3049 }
3050 return self->operator!=(*obj);
3051 }
3052 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3053 self->x = x;
3054 self->y = y;
3055 }
3056 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3057 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3058 PyObject* tup = PyTuple_New(2);
3059 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3060 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3061 //PyEndBlockThreads(blocked);
3062 return tup;
3063 }
3064 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return false;
3067 if ( ! wxPoint_helper(other, &obj) ) {
3068 PyErr_Clear();
3069 return false;
3070 }
3071 return self->operator==(*obj);
3072 }
3073 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3074 wxPoint temp, *obj = &temp;
3075 if ( other == Py_None ) return true;
3076 if ( ! wxPoint_helper(other, &obj)) {
3077 PyErr_Clear();
3078 return true;
3079 }
3080 return self->operator!=(*obj);
3081 }
3082 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3083 self->x = x;
3084 self->y = y;
3085 }
3086 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3087 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 PyObject* tup = PyTuple_New(2);
3089 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3090 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3091 //wxPyEndBlockThreads(blocked);
3092 return tup;
3093 }
3094 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return false;
3097 if ( ! wxRect_helper(other, &obj) ) {
3098 PyErr_Clear();
3099 return false;
3100 }
3101 return self->operator==(*obj);
3102 }
3103 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3104 wxRect temp, *obj = &temp;
3105 if ( other == Py_None ) return true;
3106 if ( ! wxRect_helper(other, &obj)) {
3107 PyErr_Clear();
3108 return true;
3109 }
3110 return self->operator!=(*obj);
3111 }
3112 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3113 self->x = x;
3114 self->y = y;
3115 self->width = width;
3116 self->height = height;
3117 }
3118 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3119 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3120 PyObject* tup = PyTuple_New(4);
3121 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3122 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3123 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3124 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3125 //wxPyEndBlockThreads(blocked);
3126 return tup;
3127 }
3128
3129 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3130 wxRegion reg1(*r1);
3131 wxRegion reg2(*r2);
3132 wxRect dest(0,0,0,0);
3133 PyObject* obj;
3134
3135 reg1.Intersect(reg2);
3136 dest = reg1.GetBox();
3137
3138 if (dest != wxRect(0,0,0,0)) {
3139 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3140 wxRect* newRect = new wxRect(dest);
3141 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3142 //wxPyEndBlockThreads(blocked);
3143 return obj;
3144 }
3145 Py_INCREF(Py_None);
3146 return Py_None;
3147 }
3148
3149 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return false;
3152 if ( ! wxPoint2D_helper(other, &obj) ) {
3153 PyErr_Clear();
3154 return false;
3155 }
3156 return self->operator==(*obj);
3157 }
3158 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3159 wxPoint2D temp, *obj = &temp;
3160 if ( other == Py_None ) return true;
3161 if ( ! wxPoint2D_helper(other, &obj)) {
3162 PyErr_Clear();
3163 return true;
3164 }
3165 return self->operator!=(*obj);
3166 }
3167 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3168 self->m_x = x;
3169 self->m_y = y;
3170 }
3171 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3172 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 PyObject* tup = PyTuple_New(2);
3174 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3175 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3176 //wxPyEndBlockThreads(blocked);
3177 return tup;
3178 }
3179 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3180 wxRect2D temp, *obj = &temp;
3181 if ( other == Py_None ) return false;
3182 if ( ! wxRect2D_helper(other, &obj) ) {
3183 PyErr_Clear();
3184 return false;
3185 }
3186 return self->operator==(*obj);
3187 }
3188 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3189 wxRect2D temp, *obj = &temp;
3190 if ( other == Py_None ) return true;
3191 if ( ! wxRect2D_helper(other, &obj)) {
3192 PyErr_Clear();
3193 return true;
3194 }
3195 return self->operator!=(*obj);
3196 }
3197 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3198 self->m_x = x;
3199 self->m_y = y;
3200 self->m_width = width;
3201 self->m_height = height;
3202 }
3203 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3204 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3205 PyObject* tup = PyTuple_New(4);
3206 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3207 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3208 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3209 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3210 //wxPyEndBlockThreads(blocked);
3211 return tup;
3212 }
3213 SWIGINTERN bool wxPosition___eq__(wxPosition *self,PyObject *other){
3214 wxPosition temp, *obj = &temp;
3215 if ( other == Py_None ) return false;
3216 if ( ! wxPosition_helper(other, &obj) ) {
3217 PyErr_Clear();
3218 return false;
3219 }
3220 return self->operator==(*obj);
3221 }
3222 SWIGINTERN bool wxPosition___ne__(wxPosition *self,PyObject *other){
3223 wxPosition temp, *obj = &temp;
3224 if ( other == Py_None ) return true;
3225 if ( ! wxPosition_helper(other, &obj)) {
3226 PyErr_Clear();
3227 return true;
3228 }
3229 return self->operator!=(*obj);
3230 }
3231
3232 #include "wx/wxPython/pyistream.h"
3233
3234 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3235 wxInputStream* wxis = wxPyCBInputStream::create(p);
3236 if (wxis)
3237 return new wxPyInputStream(wxis);
3238 else
3239 return NULL;
3240 }
3241
3242 SWIGINTERN swig_type_info*
3243 SWIG_pchar_descriptor()
3244 {
3245 static int init = 0;
3246 static swig_type_info* info = 0;
3247 if (!init) {
3248 info = SWIG_TypeQuery("_p_char");
3249 init = 1;
3250 }
3251 return info;
3252 }
3253
3254
3255 SWIGINTERNINLINE PyObject *
3256 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3257 {
3258 if (carray) {
3259 if (size > INT_MAX) {
3260 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3261 return pchar_descriptor ?
3262 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3263 } else {
3264 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3265 }
3266 } else {
3267 return SWIG_Py_Void();
3268 }
3269 }
3270
3271
3272 SWIGINTERNINLINE PyObject *
3273 SWIG_From_char (char c)
3274 {
3275 return SWIG_FromCharPtrAndSize(&c,1);
3276 }
3277
3278
3279 SWIGINTERNINLINE PyObject*
3280 SWIG_From_unsigned_SS_long (unsigned long value)
3281 {
3282 return (value > LONG_MAX) ?
3283 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3284 }
3285
3286
3287 SWIGINTERNINLINE PyObject *
3288 SWIG_From_size_t (size_t value)
3289 {
3290 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3291 }
3292
3293
3294 SWIGINTERN int
3295 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3296 {
3297 if (PyString_Check(obj)) {
3298 char *cstr; Py_ssize_t len;
3299 PyString_AsStringAndSize(obj, &cstr, &len);
3300 if (cptr) {
3301 if (alloc) {
3302 /*
3303 In python the user should not be able to modify the inner
3304 string representation. To warranty that, if you define
3305 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3306 buffer is always returned.
3307
3308 The default behavior is just to return the pointer value,
3309 so, be careful.
3310 */
3311 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3312 if (*alloc != SWIG_OLDOBJ)
3313 #else
3314 if (*alloc == SWIG_NEWOBJ)
3315 #endif
3316 {
3317 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3318 *alloc = SWIG_NEWOBJ;
3319 }
3320 else {
3321 *cptr = cstr;
3322 *alloc = SWIG_OLDOBJ;
3323 }
3324 } else {
3325 *cptr = PyString_AsString(obj);
3326 }
3327 }
3328 if (psize) *psize = len + 1;
3329 return SWIG_OK;
3330 } else {
3331 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3332 if (pchar_descriptor) {
3333 void* vptr = 0;
3334 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3335 if (cptr) *cptr = (char *) vptr;
3336 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3337 if (alloc) *alloc = SWIG_OLDOBJ;
3338 return SWIG_OK;
3339 }
3340 }
3341 }
3342 return SWIG_TypeError;
3343 }
3344
3345
3346 SWIGINTERN int
3347 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3348 {
3349 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3350 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3351 if (SWIG_IsOK(res)) {
3352 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3353 if (csize <= size) {
3354 if (val) {
3355 if (csize) memcpy(val, cptr, csize*sizeof(char));
3356 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3357 }
3358 if (alloc == SWIG_NEWOBJ) {
3359 delete[] cptr;
3360 res = SWIG_DelNewMask(res);
3361 }
3362 return res;
3363 }
3364 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3365 }
3366 return SWIG_TypeError;
3367 }
3368
3369
3370 SWIGINTERN int
3371 SWIG_AsVal_char (PyObject * obj, char *val)
3372 {
3373 int res = SWIG_AsCharArray(obj, val, 1);
3374 if (!SWIG_IsOK(res)) {
3375 long v;
3376 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3377 if (SWIG_IsOK(res)) {
3378 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3379 if (val) *val = static_cast< char >(v);
3380 } else {
3381 res = SWIG_OverflowError;
3382 }
3383 }
3384 }
3385 return res;
3386 }
3387
3388 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3389 // We use only strings for the streams, not unicode
3390 PyObject* str = PyObject_Str(obj);
3391 if (! str) {
3392 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3393 return;
3394 }
3395 self->Write(PyString_AS_STRING(str),
3396 PyString_GET_SIZE(str));
3397 Py_DECREF(str);
3398 }
3399
3400 #include "wx/wxPython/pyistream.h"
3401
3402
3403 class wxPyFileSystemHandler : public wxFileSystemHandler
3404 {
3405 public:
3406 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3407
3408 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3409 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3410 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3411 DEC_PYCALLBACK_STRING__pure(FindNext);
3412
3413 wxString GetProtocol(const wxString& location) {
3414 return wxFileSystemHandler::GetProtocol(location);
3415 }
3416
3417 wxString GetLeftLocation(const wxString& location) {
3418 return wxFileSystemHandler::GetLeftLocation(location);
3419 }
3420
3421 wxString GetAnchor(const wxString& location) {
3422 return wxFileSystemHandler::GetAnchor(location);
3423 }
3424
3425 wxString GetRightLocation(const wxString& location) {
3426 return wxFileSystemHandler::GetRightLocation(location);
3427 }
3428
3429 wxString GetMimeTypeFromExt(const wxString& location) {
3430 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3431 }
3432
3433 PYPRIVATE;
3434 };
3435
3436
3437 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3438 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3439 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3440 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3441
3442
3443 SWIGINTERN int
3444 SWIG_AsVal_bool (PyObject *obj, bool *val)
3445 {
3446 if (obj == Py_True) {
3447 if (val) *val = true;
3448 return SWIG_OK;
3449 } else if (obj == Py_False) {
3450 if (val) *val = false;
3451 return SWIG_OK;
3452 } else {
3453 long v = 0;
3454 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3455 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3456 return res;
3457 }
3458 }
3459
3460 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3461 wxFileName fname = wxFileSystem::URLToFileName(url);
3462 return fname.GetFullPath();
3463 }
3464
3465 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3466 wxImage& image,
3467 long type) {
3468 wxMemoryFSHandler::AddFile(filename, image, type);
3469 }
3470
3471 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3472 const wxBitmap& bitmap,
3473 long type) {
3474 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3475 }
3476
3477 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3478 PyObject* data) {
3479 if (! PyString_Check(data)) {
3480 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3481 "Expected string object"));
3482 return;
3483 }
3484
3485 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3486 void* ptr = (void*)PyString_AsString(data);
3487 size_t size = PyString_Size(data);
3488 wxPyEndBlockThreads(blocked);
3489
3490 wxMemoryFSHandler::AddFile(filename, ptr, size);
3491 }
3492
3493
3494 #include "wx/wxPython/pyistream.h"
3495
3496
3497 SWIGINTERN int
3498 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3499 {
3500 long v = 0;
3501 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3502 return SWIG_TypeError;
3503 }
3504 else if (val)
3505 *val = (unsigned long)v;
3506 return SWIG_OK;
3507 }
3508
3509
3510 SWIGINTERN int
3511 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3512 {
3513 unsigned long v;
3514 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3515 if (SWIG_IsOK(res)) {
3516 if ((v > UCHAR_MAX)) {
3517 return SWIG_OverflowError;
3518 } else {
3519 if (val) *val = static_cast< unsigned char >(v);
3520 }
3521 }
3522 return res;
3523 }
3524
3525
3526 SWIGINTERNINLINE PyObject *
3527 SWIG_From_unsigned_SS_char (unsigned char value)
3528 {
3529 return SWIG_From_unsigned_SS_long (value);
3530 }
3531
3532 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3533 wxImageHistogramEntry e = (*self)[key];
3534 return e.value;
3535 }
3536 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3537 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3538 wxImageHistogramEntry e = (*self)[key];
3539 return e.value;
3540 }
3541 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3542 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3543 colour.Green(),
3544 colour.Blue());
3545 wxImageHistogramEntry e = (*self)[key];
3546 return e.value;
3547 }
3548
3549 // Pull the nested class out to the top level for SWIG's sake
3550 #define wxImage_RGBValue wxImage::RGBValue
3551 #define wxImage_HSVValue wxImage::HSVValue
3552
3553 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3554 if (width > 0 && height > 0)
3555 return new wxImage(width, height, clear);
3556 else
3557 return new wxImage;
3558 }
3559 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3560 return new wxImage(bitmap.ConvertToImage());
3561 }
3562 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3563 if (DATASIZE != width*height*3) {
3564 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3565 return NULL;
3566 }
3567
3568 // Copy the source data so the wxImage can clean it up later
3569 buffer copy = (buffer)malloc(DATASIZE);
3570 if (copy == NULL) {
3571 wxPyBLOCK_THREADS(PyErr_NoMemory());
3572 return NULL;
3573 }
3574 memcpy(copy, data, DATASIZE);
3575 return new wxImage(width, height, copy, false);
3576 }
3577 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3578 if (DATASIZE != width*height*3) {
3579 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3580 return NULL;
3581 }
3582 if (ALPHASIZE != width*height) {
3583 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3584 return NULL;
3585 }
3586
3587 // Copy the source data so the wxImage can clean it up later
3588 buffer dcopy = (buffer)malloc(DATASIZE);
3589 if (dcopy == NULL) {
3590 wxPyBLOCK_THREADS(PyErr_NoMemory());
3591 return NULL;
3592 }
3593 memcpy(dcopy, data, DATASIZE);
3594
3595 buffer acopy = (buffer)malloc(ALPHASIZE);
3596 if (acopy == NULL) {
3597 wxPyBLOCK_THREADS(PyErr_NoMemory());
3598 return NULL;
3599 }
3600 memcpy(acopy, alpha, ALPHASIZE);
3601
3602 return new wxImage(width, height, dcopy, acopy, false);
3603 }
3604 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3605 wxSize size(self->GetWidth(), self->GetHeight());
3606 return size;
3607 }
3608 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3609 buffer data = self->GetData();
3610 int len = self->GetWidth() * self->GetHeight() * 3;
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3616 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3618 return;
3619 }
3620 buffer copy = (buffer)malloc(DATASIZE);
3621 if (copy == NULL) {
3622 wxPyBLOCK_THREADS(PyErr_NoMemory());
3623 return;
3624 }
3625 memcpy(copy, data, DATASIZE);
3626 self->SetData(copy, false);
3627 // wxImage takes ownership of copy...
3628 }
3629 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3630 buffer data = self->GetData();
3631 int len = self->GetWidth() * self->GetHeight() * 3;
3632 PyObject* rv;
3633 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3634 return rv;
3635 }
3636 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3637 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return;
3640 }
3641 self->SetData(data, true);
3642 }
3643 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3644 buffer data = self->GetAlpha();
3645 if (! data) {
3646 RETURN_NONE();
3647 } else {
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3651 return rv;
3652 }
3653 }
3654 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3655 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3656 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3657 return;
3658 }
3659 buffer acopy = (buffer)malloc(ALPHASIZE);
3660 if (acopy == NULL) {
3661 wxPyBLOCK_THREADS(PyErr_NoMemory());
3662 return;
3663 }
3664 memcpy(acopy, alpha, ALPHASIZE);
3665 self->SetAlpha(acopy, false);
3666 // wxImage takes ownership of acopy...
3667 }
3668 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3669 buffer data = self->GetAlpha();
3670 int len = self->GetWidth() * self->GetHeight();
3671 PyObject* rv;
3672 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3673 return rv;
3674 }
3675 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3676 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3677 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3678 return;
3679 }
3680 self->SetAlpha(alpha, true);
3681 }
3682 SWIGINTERN PyObject *wxImage_GetHandlers(){
3683 wxList& list = wxImage::GetHandlers();
3684 return wxPy_ConvertList(&list);
3685 }
3686 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3687 wxBitmap bitmap(*self, depth);
3688 return bitmap;
3689 }
3690 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3691 wxImage mono = self->ConvertToMono( red, green, blue );
3692 wxBitmap bitmap( mono, 1 );
3693 return bitmap;
3694 }
3695
3696 wxImage* _ImageFromBuffer(int width, int height,
3697 buffer data, int DATASIZE,
3698 buffer alpha=NULL, int ALPHASIZE=0)
3699 {
3700 if (DATASIZE != width*height*3) {
3701 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3702 return NULL;
3703 }
3704 if (alpha != NULL) {
3705 if (ALPHASIZE != width*height) {
3706 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3707 return NULL;
3708 }
3709 return new wxImage(width, height, data, alpha, true);
3710 }
3711 return new wxImage(width, height, data, true);
3712 }
3713
3714 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3715 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3716 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3717 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3718 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3719 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3720 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3721 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3722 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3723 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3724 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3725 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3726 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3727 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3728 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3729
3730 #include <wx/imagtga.h>
3731
3732
3733 #include <wx/quantize.h>
3734
3735 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3736 return wxQuantize::Quantize(src, dest,
3737 //NULL, // palette
3738 desiredNoColours,
3739 NULL, // eightBitData
3740 flags);
3741 }
3742 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3743 if (PyCallable_Check(func)) {
3744 self->Connect(id, lastId, eventType,
3745 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3746 new wxPyCallback(func));
3747 }
3748 else if (func == Py_None) {
3749 self->Disconnect(id, lastId, eventType,
3750 (wxObjectEventFunction)
3751 &wxPyCallback::EventThunker);
3752 }
3753 else {
3754 wxPyBLOCK_THREADS(
3755 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3756 }
3757 }
3758 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3759 return self->Disconnect(id, lastId, eventType,
3760 (wxObjectEventFunction)
3761 &wxPyCallback::EventThunker);
3762 }
3763 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3764 if (_self && _self != Py_None) {
3765 self->SetClientObject(new wxPyOORClientData(_self, incref));
3766 }
3767 else {
3768 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3769 if (data) {
3770 self->SetClientObject(NULL); // This will delete it too
3771 }
3772 }
3773 }
3774
3775 #if ! wxUSE_HOTKEY
3776 #define wxEVT_HOTKEY -9999
3777 #endif
3778
3779 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3780 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3781 if (data) {
3782 Py_INCREF(data->m_obj);
3783 return data->m_obj;
3784 } else {
3785 Py_INCREF(Py_None);
3786 return Py_None;
3787 }
3788 }
3789 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3790 wxPyClientData* data = new wxPyClientData(clientData);
3791 self->SetClientObject(data);
3792 }
3793 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3794 #if wxUSE_UNICODE
3795 return self->GetUnicodeKey();
3796 #else
3797 return 0;
3798 #endif
3799 }
3800 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3801 #if wxUSE_UNICODE
3802 self->m_uniChar = uniChar;
3803 #endif
3804 }
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_From_unsigned_SS_int (unsigned int value)
3808 {
3809 return SWIG_From_unsigned_SS_long (value);
3810 }
3811
3812
3813 SWIGINTERN int
3814 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3815 {
3816 unsigned long v;
3817 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3818 if (SWIG_IsOK(res)) {
3819 if ((v > UINT_MAX)) {
3820 return SWIG_OverflowError;
3821 } else {
3822 if (val) *val = static_cast< unsigned int >(v);
3823 }
3824 }
3825 return res;
3826 }
3827
3828 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3829 self->m_size = size;
3830 }
3831 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3832 int count = self->GetNumberOfFiles();
3833 wxString* files = self->GetFiles();
3834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3835 PyObject* list = PyList_New(count);
3836
3837 if (!list) {
3838 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3839 wxPyEndBlockThreads(blocked);
3840 return NULL;
3841 }
3842
3843 for (int i=0; i<count; i++) {
3844 PyList_SetItem(list, i, wx2PyString(files[i]));
3845 }
3846 wxPyEndBlockThreads(blocked);
3847 return list;
3848 }
3849
3850
3851 SWIGINTERN wxPyApp *new_wxPyApp(){
3852 wxPythonApp = new wxPyApp();
3853 return wxPythonApp;
3854 }
3855 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3856 return wxPyTestDisplayAvailable();
3857 }
3858
3859 void wxApp_CleanUp() {
3860 __wxPyCleanup();
3861 }
3862
3863
3864 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3865
3866
3867
3868
3869
3870 SWIGINTERNINLINE PyObject *
3871 SWIG_FromCharPtr(const char *cptr)
3872 {
3873 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3874 }
3875
3876
3877 #if 0 // #ifdef __WXMAC__
3878
3879 // A dummy class that raises an exception if used...
3880 class wxEventLoop
3881 {
3882 public:
3883 wxEventLoop() { wxPyRaiseNotImplemented(); }
3884 int Run() { return 0; }
3885 void Exit(int rc = 0) {}
3886 bool Pending() const { return false; }
3887 bool Dispatch() { return false; }
3888 bool IsRunning() const { return false; }
3889 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3890 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3891 };
3892
3893 #else
3894
3895 #include <wx/evtloop.h>
3896
3897 #endif
3898
3899
3900
3901 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3902 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3903 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3904 SWIGINTERN wxFont wxVisualAttributes__get_font(wxVisualAttributes *self){ return self->font; }
3905 SWIGINTERN wxColour wxVisualAttributes__get_colFg(wxVisualAttributes *self){ return self->colFg; }
3906 SWIGINTERN wxColour wxVisualAttributes__get_colBg(wxVisualAttributes *self){ return self->colBg; }
3907 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3908 wxWindowList& list = self->GetChildren();
3909 return wxPy_ConvertList(&list);
3910 }
3911 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3912 return wxGetTopLevelParent(self);
3913 }
3914 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3915 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3916 #if wxUSE_HOTKEY
3917 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3918 #else
3919 return false;
3920 #endif
3921 }
3922 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3923
3924
3925
3926 return false;
3927
3928 }
3929 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3930 return wxPyGetWinHandle(self);
3931 }
3932 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3933 self->AssociateHandle((WXWidget)handle);
3934 }
3935
3936 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3937 return wxWindow::FindWindowById(id, parent);
3938 }
3939
3940 wxWindow* wxFindWindowByName( const wxString& name,
3941 const wxWindow *parent = NULL ) {
3942 return wxWindow::FindWindowByName(name, parent);
3943 }
3944
3945 wxWindow* wxFindWindowByLabel( const wxString& label,
3946 const wxWindow *parent = NULL ) {
3947 return wxWindow::FindWindowByLabel(label, parent);
3948 }
3949
3950
3951 #ifdef __WXMSW__
3952 #include <wx/msw/private.h> // to get wxGetWindowId
3953 #endif
3954
3955
3956 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3957 #ifdef __WXMSW__
3958 WXHWND hWnd = (WXHWND)_hWnd;
3959 long id = wxGetWindowId(hWnd);
3960 wxWindow* win = new wxWindow;
3961 if (parent)
3962 parent->AddChild(win);
3963 win->SetEventHandler(win);
3964 win->SetHWND(hWnd);
3965 win->SetId(id);
3966 win->SubclassWin(hWnd);
3967 win->AdoptAttributesFromHWND();
3968 win->SetupColours();
3969 return win;
3970 #else
3971 wxPyRaiseNotImplemented();
3972 return NULL;
3973 #endif
3974 }
3975
3976
3977 PyObject* GetTopLevelWindows() {
3978 return wxPy_ConvertList(&wxTopLevelWindows);
3979 }
3980
3981
3982 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3983 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3984 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3985
3986 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3987
3988
3989 SWIGINTERNINLINE int
3990 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3991 {
3992 unsigned long v;
3993 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3994 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3995 return res;
3996 }
3997
3998 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3999 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
4000 wxMenuItemList& list = self->GetMenuItems();
4001 return wxPy_ConvertList(&list);
4002 }
4003 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
4004 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
4005 static const wxString wxPyControlNameStr(wxControlNameStr);
4006 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
4007 if (clientData) {
4008 wxPyClientData* data = new wxPyClientData(clientData);
4009 return self->Append(item, data);
4010 } else
4011 return self->Append(item);
4012 }
4013 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4014 if (clientData) {
4015 wxPyClientData* data = new wxPyClientData(clientData);
4016 return self->Insert(item, pos, data);
4017 } else
4018 return self->Insert(item, pos);
4019 }
4020 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4021 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4022 if (data) {
4023 Py_INCREF(data->m_obj);
4024 return data->m_obj;
4025 } else {
4026 Py_INCREF(Py_None);
4027 return Py_None;
4028 }
4029 }
4030 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4031 wxPyClientData* data = new wxPyClientData(clientData);
4032 self->SetClientObject(n, data);
4033 }
4034
4035
4036 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4037 if (borderInPixels == -1)
4038 return self->Border(direction);
4039 else
4040 return self->Border(direction, borderInPixels);
4041 }
4042 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4043 wxPyUserData* data = NULL;
4044 if ( userData ) {
4045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4046 data = new wxPyUserData(userData);
4047 wxPyEndBlockThreads(blocked);
4048 }
4049 return new wxSizerItem(window, proportion, flag, border, data);
4050 }
4051 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4052 wxPyUserData* data = NULL;
4053 if ( userData ) {
4054 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4055 data = new wxPyUserData(userData);
4056 wxPyEndBlockThreads(blocked);
4057 }
4058 return new wxSizerItem(width, height, proportion, flag, border, data);
4059 }
4060 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4061 wxPyUserData* data = NULL;
4062 if ( userData ) {
4063 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4064 data = new wxPyUserData(userData);
4065 wxPyEndBlockThreads(blocked);
4066 }
4067 return new wxSizerItem(sizer, proportion, flag, border, data);
4068 }
4069
4070 SWIGINTERNINLINE PyObject *
4071 SWIG_From_float (float value)
4072 {
4073 return SWIG_From_double (value);
4074 }
4075
4076 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4077 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4078 if (data) {
4079 Py_INCREF(data->m_obj);
4080 return data->m_obj;
4081 } else {
4082 Py_INCREF(Py_None);
4083 return Py_None;
4084 }
4085 }
4086 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4087 wxPyUserData* data = NULL;
4088 if ( userData ) {
4089 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4090 data = new wxPyUserData(userData);
4091 wxPyEndBlockThreads(blocked);
4092 }
4093 self->SetUserData(data);
4094 }
4095
4096 // Figure out the type of the sizer item
4097
4098 struct wxPySizerItemInfo {
4099 wxPySizerItemInfo()
4100 : window(NULL), sizer(NULL), gotSize(false),
4101 size(wxDefaultSize), gotPos(false), pos(-1)
4102 {}
4103
4104 wxWindow* window;
4105 wxSizer* sizer;
4106 bool gotSize;
4107 wxSize size;
4108 bool gotPos;
4109 int pos;
4110 };
4111
4112 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4113
4114 wxPySizerItemInfo info;
4115 wxSize size;
4116 wxSize* sizePtr = &size;
4117
4118 // Find out what the type of the item is
4119 // try wxWindow
4120 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4121 PyErr_Clear();
4122 info.window = NULL;
4123
4124 // try wxSizer
4125 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4126 PyErr_Clear();
4127 info.sizer = NULL;
4128
4129 // try wxSize or (w,h)
4130 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4131 info.size = *sizePtr;
4132 info.gotSize = true;
4133 }
4134
4135 // or a single int
4136 if (checkIdx && PyInt_Check(item)) {
4137 info.pos = PyInt_AsLong(item);
4138 info.gotPos = true;
4139 }
4140 }
4141 }
4142
4143 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4144 // no expected type, figure out what kind of error message to generate
4145 if ( !checkSize && !checkIdx )
4146 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4147 else if ( checkSize && !checkIdx )
4148 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4149 else if ( !checkSize && checkIdx)
4150 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4151 else
4152 // can this one happen?
4153 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4154 }
4155
4156 return info;
4157 }
4158
4159 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4160 if (!self->GetClientObject())
4161 self->SetClientObject(new wxPyOORClientData(_self));
4162 }
4163 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4164
4165 wxPyUserData* data = NULL;
4166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4167 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4168 if ( userData && (info.window || info.sizer || info.gotSize) )
4169 data = new wxPyUserData(userData);
4170 if ( info.sizer )
4171 PyObject_SetAttrString(item,"thisown",Py_False);
4172 wxPyEndBlockThreads(blocked);
4173
4174 // Now call the real Add method if a valid item type was found
4175 if ( info.window )
4176 return self->Add(info.window, proportion, flag, border, data);
4177 else if ( info.sizer )
4178 return self->Add(info.sizer, proportion, flag, border, data);
4179 else if (info.gotSize)
4180 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4181 proportion, flag, border, data);
4182 else
4183 return NULL;
4184 }
4185 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4186
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4189 if ( info.sizer )
4190 PyObject_SetAttrString(item,"thisown",Py_False);
4191 wxPyEndBlockThreads(blocked);
4192
4193 // Now call the real Add method if a valid item type was found
4194 if ( info.window )
4195 return self->Add(info.window, flags);
4196 else if ( info.sizer )
4197 return self->Add(info.sizer, flags);
4198 else if (info.gotSize)
4199 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4200 flags.GetProportion(),
4201 flags.GetFlags(),
4202 flags.GetBorderInPixels());
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4207
4208 wxPyUserData* data = NULL;
4209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4210 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4211 if ( userData && (info.window || info.sizer || info.gotSize) )
4212 data = new wxPyUserData(userData);
4213 if ( info.sizer )
4214 PyObject_SetAttrString(item,"thisown",Py_False);
4215 wxPyEndBlockThreads(blocked);
4216
4217 // Now call the real Insert method if a valid item type was found
4218 if ( info.window )
4219 return self->Insert(before, info.window, proportion, flag, border, data);
4220 else if ( info.sizer )
4221 return self->Insert(before, info.sizer, proportion, flag, border, data);
4222 else if (info.gotSize)
4223 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4224 proportion, flag, border, data);
4225 else
4226 return NULL;
4227 }
4228 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4229
4230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4231 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4232 if ( info.sizer )
4233 PyObject_SetAttrString(item,"thisown",Py_False);
4234 wxPyEndBlockThreads(blocked);
4235
4236 // Now call the real Insert method if a valid item type was found
4237 if ( info.window )
4238 return self->Insert(before, info.window, flags);
4239 else if ( info.sizer )
4240 return self->Insert(before, info.sizer, flags);
4241 else if (info.gotSize)
4242 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4243 flags.GetProportion(),
4244 flags.GetFlags(),
4245 flags.GetBorderInPixels());
4246 else
4247 return NULL;
4248 }
4249 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4250
4251 wxPyUserData* data = NULL;
4252 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4253 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4254 if ( userData && (info.window || info.sizer || info.gotSize) )
4255 data = new wxPyUserData(userData);
4256 if ( info.sizer )
4257 PyObject_SetAttrString(item,"thisown",Py_False);
4258 wxPyEndBlockThreads(blocked);
4259
4260 // Now call the real Prepend method if a valid item type was found
4261 if ( info.window )
4262 return self->Prepend(info.window, proportion, flag, border, data);
4263 else if ( info.sizer )
4264 return self->Prepend(info.sizer, proportion, flag, border, data);
4265 else if (info.gotSize)
4266 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4267 proportion, flag, border, data);
4268 else
4269 return NULL;
4270 }
4271 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4272
4273 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4274 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4275 if ( info.sizer )
4276 PyObject_SetAttrString(item,"thisown",Py_False);
4277 wxPyEndBlockThreads(blocked);
4278
4279 // Now call the real Add method if a valid item type was found
4280 if ( info.window )
4281 return self->Prepend(info.window, flags);
4282 else if ( info.sizer )
4283 return self->Prepend(info.sizer, flags);
4284 else if (info.gotSize)
4285 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4286 flags.GetProportion(),
4287 flags.GetFlags(),
4288 flags.GetBorderInPixels());
4289 else
4290 return NULL;
4291 }
4292 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4293 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4294 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4295 wxPyEndBlockThreads(blocked);
4296 if ( info.window )
4297 return false; //self->Remove(info.window);
4298 else if ( info.sizer )
4299 return self->Remove(info.sizer);
4300 else if ( info.gotPos )
4301 return self->Remove(info.pos);
4302 else
4303 return false;
4304 }
4305 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4306 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4307 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4308 wxPyEndBlockThreads(blocked);
4309 if ( info.window )
4310 return self->Detach(info.window);
4311 else if ( info.sizer )
4312 return self->Detach(info.sizer);
4313 else if ( info.gotPos )
4314 return self->Detach(info.pos);
4315 else
4316 return false;
4317 }
4318 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4320 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4321 wxPyEndBlockThreads(blocked);
4322 if ( info.window )
4323 return self->GetItem(info.window, recursive);
4324 else if ( info.sizer )
4325 return self->GetItem(info.sizer, recursive);
4326 else if ( info.gotPos )
4327 return self->GetItem(info.pos);
4328 else
4329 return NULL;
4330 }
4331 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4333 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4334 wxPyEndBlockThreads(blocked);
4335 if ( info.window )
4336 self->SetItemMinSize(info.window, size);
4337 else if ( info.sizer )
4338 self->SetItemMinSize(info.sizer, size);
4339 else if ( info.gotPos )
4340 self->SetItemMinSize(info.pos, size);
4341 }
4342 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4343 wxSizerItemList& list = self->GetChildren();
4344 return wxPy_ConvertList(&list);
4345 }
4346 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4349 wxPyEndBlockThreads(blocked);
4350 if ( info.window )
4351 return self->Show(info.window, show, recursive);
4352 else if ( info.sizer )
4353 return self->Show(info.sizer, show, recursive);
4354 else if ( info.gotPos )
4355 return self->Show(info.pos, show);
4356 else
4357 return false;
4358 }
4359 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4360 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4361 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4362 wxPyEndBlockThreads(blocked);
4363 if ( info.window )
4364 return self->IsShown(info.window);
4365 else if ( info.sizer )
4366 return self->IsShown(info.sizer);
4367 else if ( info.gotPos )
4368 return self->IsShown(info.pos);
4369 else
4370 return false;
4371 }
4372
4373 // See pyclasses.h
4374 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4375 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4376 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4377
4378
4379
4380
4381 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4382 {
4383 if (source == Py_None) {
4384 **obj = wxGBPosition(-1,-1);
4385 return true;
4386 }
4387 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4388 }
4389
4390 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4391 {
4392 if (source == Py_None) {
4393 **obj = wxGBSpan(-1,-1);
4394 return true;
4395 }
4396 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4397 }
4398
4399
4400 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4401 wxGBPosition temp, *obj = &temp;
4402 if ( other == Py_None ) return false;
4403 if ( ! wxGBPosition_helper(other, &obj) ) {
4404 PyErr_Clear();
4405 return false;
4406 }
4407 return self->operator==(*obj);
4408 }
4409 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4410 wxGBPosition temp, *obj = &temp;
4411 if ( other == Py_None ) return true;
4412 if ( ! wxGBPosition_helper(other, &obj)) {
4413 PyErr_Clear();
4414 return true;
4415 }
4416 return self->operator!=(*obj);
4417 }
4418 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4419 self->SetRow(row);
4420 self->SetCol(col);
4421 }
4422 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4424 PyObject* tup = PyTuple_New(2);
4425 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4426 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4427 wxPyEndBlockThreads(blocked);
4428 return tup;
4429 }
4430 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4431 wxGBSpan temp, *obj = &temp;
4432 if ( other == Py_None ) return false;
4433 if ( ! wxGBSpan_helper(other, &obj) ) {
4434 PyErr_Clear();
4435 return false;
4436 }
4437 return self->operator==(*obj);
4438 }
4439 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4440 wxGBSpan temp, *obj = &temp;
4441 if ( other == Py_None ) return true;
4442 if ( ! wxGBSpan_helper(other, &obj)) {
4443 PyErr_Clear();
4444 return true;
4445 }
4446 return self->operator!=(*obj);
4447 }
4448 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4449 self->SetRowspan(rowspan);
4450 self->SetColspan(colspan);
4451 }
4452 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4453 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4454 PyObject* tup = PyTuple_New(2);
4455 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4456 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4457 wxPyEndBlockThreads(blocked);
4458 return tup;
4459 }
4460 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4461 wxPyUserData* data = NULL;
4462 if ( userData ) {
4463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4464 data = new wxPyUserData(userData);
4465 wxPyEndBlockThreads(blocked);
4466 }
4467 return new wxGBSizerItem(window, pos, span, flag, border, data);
4468 }
4469 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4470 wxPyUserData* data = NULL;
4471 if ( userData ) {
4472 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4473 data = new wxPyUserData(userData);
4474 wxPyEndBlockThreads(blocked);
4475 }
4476 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4477 }
4478 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4479 wxPyUserData* data = NULL;
4480 if ( userData ) {
4481 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4482 data = new wxPyUserData(userData);
4483 wxPyEndBlockThreads(blocked);
4484 }
4485 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4486 }
4487 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4488 int row, col;
4489 self->GetEndPos(row, col);
4490 return wxGBPosition(row, col);
4491 }
4492 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4493
4494 wxPyUserData* data = NULL;
4495 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4496 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4497 if ( userData && (info.window || info.sizer || info.gotSize) )
4498 data = new wxPyUserData(userData);
4499 if ( info.sizer )
4500 PyObject_SetAttrString(item,"thisown",Py_False);
4501 wxPyEndBlockThreads(blocked);
4502
4503 // Now call the real Add method if a valid item type was found
4504 if ( info.window )
4505 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4506 else if ( info.sizer )
4507 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4508 else if (info.gotSize)
4509 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4510 pos, span, flag, border, data);
4511 return NULL;
4512 }
4513
4514
4515 #ifdef __cplusplus
4516 extern "C" {
4517 #endif
4518 SWIGINTERN int EmptyString_set(PyObject *) {
4519 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4520 return 1;
4521 }
4522
4523
4524 SWIGINTERN PyObject *EmptyString_get(void) {
4525 PyObject *pyobj = 0;
4526
4527 {
4528 #if wxUSE_UNICODE
4529 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4530 #else
4531 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4532 #endif
4533 }
4534 return pyobj;
4535 }
4536
4537
4538 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4539 PyObject *resultobj = 0;
4540 wxObject *arg1 = (wxObject *) 0 ;
4541 wxString result;
4542 void *argp1 = 0 ;
4543 int res1 = 0 ;
4544 PyObject *swig_obj[1] ;
4545
4546 if (!args) SWIG_fail;
4547 swig_obj[0] = args;
4548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4549 if (!SWIG_IsOK(res1)) {
4550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4551 }
4552 arg1 = reinterpret_cast< wxObject * >(argp1);
4553 {
4554 PyThreadState* __tstate = wxPyBeginAllowThreads();
4555 result = wxObject_GetClassName(arg1);
4556 wxPyEndAllowThreads(__tstate);
4557 if (PyErr_Occurred()) SWIG_fail;
4558 }
4559 {
4560 #if wxUSE_UNICODE
4561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4562 #else
4563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4564 #endif
4565 }
4566 return resultobj;
4567 fail:
4568 return NULL;
4569 }
4570
4571
4572 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4573 PyObject *resultobj = 0;
4574 wxObject *arg1 = (wxObject *) 0 ;
4575 void *argp1 = 0 ;
4576 int res1 = 0 ;
4577 PyObject *swig_obj[1] ;
4578
4579 if (!args) SWIG_fail;
4580 swig_obj[0] = args;
4581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4582 if (!SWIG_IsOK(res1)) {
4583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4584 }
4585 arg1 = reinterpret_cast< wxObject * >(argp1);
4586 {
4587 PyThreadState* __tstate = wxPyBeginAllowThreads();
4588 wxObject_Destroy(arg1);
4589 wxPyEndAllowThreads(__tstate);
4590 if (PyErr_Occurred()) SWIG_fail;
4591 }
4592 resultobj = SWIG_Py_Void();
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4600 PyObject *resultobj = 0;
4601 wxObject *arg1 = (wxObject *) 0 ;
4602 wxObject *arg2 = 0 ;
4603 bool result;
4604 void *argp1 = 0 ;
4605 int res1 = 0 ;
4606 void *argp2 = 0 ;
4607 int res2 = 0 ;
4608 PyObject * obj0 = 0 ;
4609 PyObject * obj1 = 0 ;
4610 char * kwnames[] = {
4611 (char *) "self",(char *) "p", NULL
4612 };
4613
4614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4616 if (!SWIG_IsOK(res1)) {
4617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4618 }
4619 arg1 = reinterpret_cast< wxObject * >(argp1);
4620 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4621 if (!SWIG_IsOK(res2)) {
4622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4623 }
4624 if (!argp2) {
4625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4626 }
4627 arg2 = reinterpret_cast< wxObject * >(argp2);
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4631 wxPyEndAllowThreads(__tstate);
4632 if (PyErr_Occurred()) SWIG_fail;
4633 }
4634 {
4635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4636 }
4637 return resultobj;
4638 fail:
4639 return NULL;
4640 }
4641
4642
4643 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4644 PyObject *obj;
4645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4646 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4647 return SWIG_Py_Void();
4648 }
4649
4650 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4651 PyObject *resultobj = 0;
4652 wxSize *arg1 = (wxSize *) 0 ;
4653 int arg2 ;
4654 void *argp1 = 0 ;
4655 int res1 = 0 ;
4656 int val2 ;
4657 int ecode2 = 0 ;
4658 PyObject *swig_obj[2] ;
4659
4660 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4662 if (!SWIG_IsOK(res1)) {
4663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4664 }
4665 arg1 = reinterpret_cast< wxSize * >(argp1);
4666 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4667 if (!SWIG_IsOK(ecode2)) {
4668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4669 }
4670 arg2 = static_cast< int >(val2);
4671 if (arg1) (arg1)->x = arg2;
4672
4673 resultobj = SWIG_Py_Void();
4674 return resultobj;
4675 fail:
4676 return NULL;
4677 }
4678
4679
4680 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4681 PyObject *resultobj = 0;
4682 wxSize *arg1 = (wxSize *) 0 ;
4683 int result;
4684 void *argp1 = 0 ;
4685 int res1 = 0 ;
4686 PyObject *swig_obj[1] ;
4687
4688 if (!args) SWIG_fail;
4689 swig_obj[0] = args;
4690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4691 if (!SWIG_IsOK(res1)) {
4692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4693 }
4694 arg1 = reinterpret_cast< wxSize * >(argp1);
4695 result = (int) ((arg1)->x);
4696 resultobj = SWIG_From_int(static_cast< int >(result));
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4704 PyObject *resultobj = 0;
4705 wxSize *arg1 = (wxSize *) 0 ;
4706 int arg2 ;
4707 void *argp1 = 0 ;
4708 int res1 = 0 ;
4709 int val2 ;
4710 int ecode2 = 0 ;
4711 PyObject *swig_obj[2] ;
4712
4713 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4715 if (!SWIG_IsOK(res1)) {
4716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4717 }
4718 arg1 = reinterpret_cast< wxSize * >(argp1);
4719 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4720 if (!SWIG_IsOK(ecode2)) {
4721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4722 }
4723 arg2 = static_cast< int >(val2);
4724 if (arg1) (arg1)->y = arg2;
4725
4726 resultobj = SWIG_Py_Void();
4727 return resultobj;
4728 fail:
4729 return NULL;
4730 }
4731
4732
4733 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4734 PyObject *resultobj = 0;
4735 wxSize *arg1 = (wxSize *) 0 ;
4736 int result;
4737 void *argp1 = 0 ;
4738 int res1 = 0 ;
4739 PyObject *swig_obj[1] ;
4740
4741 if (!args) SWIG_fail;
4742 swig_obj[0] = args;
4743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4744 if (!SWIG_IsOK(res1)) {
4745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4746 }
4747 arg1 = reinterpret_cast< wxSize * >(argp1);
4748 result = (int) ((arg1)->y);
4749 resultobj = SWIG_From_int(static_cast< int >(result));
4750 return resultobj;
4751 fail:
4752 return NULL;
4753 }
4754
4755
4756 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4757 PyObject *resultobj = 0;
4758 int arg1 = (int) 0 ;
4759 int arg2 = (int) 0 ;
4760 wxSize *result = 0 ;
4761 int val1 ;
4762 int ecode1 = 0 ;
4763 int val2 ;
4764 int ecode2 = 0 ;
4765 PyObject * obj0 = 0 ;
4766 PyObject * obj1 = 0 ;
4767 char * kwnames[] = {
4768 (char *) "w",(char *) "h", NULL
4769 };
4770
4771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4772 if (obj0) {
4773 ecode1 = SWIG_AsVal_int(obj0, &val1);
4774 if (!SWIG_IsOK(ecode1)) {
4775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4776 }
4777 arg1 = static_cast< int >(val1);
4778 }
4779 if (obj1) {
4780 ecode2 = SWIG_AsVal_int(obj1, &val2);
4781 if (!SWIG_IsOK(ecode2)) {
4782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4783 }
4784 arg2 = static_cast< int >(val2);
4785 }
4786 {
4787 result = (wxSize *)new wxSize(arg1,arg2);
4788 if (PyErr_Occurred()) SWIG_fail;
4789 }
4790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4791 return resultobj;
4792 fail:
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4798 PyObject *resultobj = 0;
4799 wxSize *arg1 = (wxSize *) 0 ;
4800 void *argp1 = 0 ;
4801 int res1 = 0 ;
4802 PyObject *swig_obj[1] ;
4803
4804 if (!args) SWIG_fail;
4805 swig_obj[0] = args;
4806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4807 if (!SWIG_IsOK(res1)) {
4808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4809 }
4810 arg1 = reinterpret_cast< wxSize * >(argp1);
4811 {
4812 delete arg1;
4813
4814 if (PyErr_Occurred()) SWIG_fail;
4815 }
4816 resultobj = SWIG_Py_Void();
4817 return resultobj;
4818 fail:
4819 return NULL;
4820 }
4821
4822
4823 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4824 PyObject *resultobj = 0;
4825 wxSize *arg1 = (wxSize *) 0 ;
4826 PyObject *arg2 = (PyObject *) 0 ;
4827 bool result;
4828 void *argp1 = 0 ;
4829 int res1 = 0 ;
4830 PyObject * obj0 = 0 ;
4831 PyObject * obj1 = 0 ;
4832 char * kwnames[] = {
4833 (char *) "self",(char *) "other", NULL
4834 };
4835
4836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4838 if (!SWIG_IsOK(res1)) {
4839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4840 }
4841 arg1 = reinterpret_cast< wxSize * >(argp1);
4842 arg2 = obj1;
4843 {
4844 result = (bool)wxSize___eq__(arg1,arg2);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 {
4848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4849 }
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj = 0;
4858 wxSize *arg1 = (wxSize *) 0 ;
4859 PyObject *arg2 = (PyObject *) 0 ;
4860 bool result;
4861 void *argp1 = 0 ;
4862 int res1 = 0 ;
4863 PyObject * obj0 = 0 ;
4864 PyObject * obj1 = 0 ;
4865 char * kwnames[] = {
4866 (char *) "self",(char *) "other", NULL
4867 };
4868
4869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4871 if (!SWIG_IsOK(res1)) {
4872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4873 }
4874 arg1 = reinterpret_cast< wxSize * >(argp1);
4875 arg2 = obj1;
4876 {
4877 result = (bool)wxSize___ne__(arg1,arg2);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 {
4881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4882 }
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj = 0;
4891 wxSize *arg1 = (wxSize *) 0 ;
4892 wxSize *arg2 = 0 ;
4893 wxSize result;
4894 void *argp1 = 0 ;
4895 int res1 = 0 ;
4896 wxSize temp2 ;
4897 PyObject * obj0 = 0 ;
4898 PyObject * obj1 = 0 ;
4899 char * kwnames[] = {
4900 (char *) "self",(char *) "sz", NULL
4901 };
4902
4903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4905 if (!SWIG_IsOK(res1)) {
4906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4907 }
4908 arg1 = reinterpret_cast< wxSize * >(argp1);
4909 {
4910 arg2 = &temp2;
4911 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4912 }
4913 {
4914 result = (arg1)->operator +((wxSize const &)*arg2);
4915 if (PyErr_Occurred()) SWIG_fail;
4916 }
4917 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4918 return resultobj;
4919 fail:
4920 return NULL;
4921 }
4922
4923
4924 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4925 PyObject *resultobj = 0;
4926 wxSize *arg1 = (wxSize *) 0 ;
4927 wxSize *arg2 = 0 ;
4928 wxSize result;
4929 void *argp1 = 0 ;
4930 int res1 = 0 ;
4931 wxSize temp2 ;
4932 PyObject * obj0 = 0 ;
4933 PyObject * obj1 = 0 ;
4934 char * kwnames[] = {
4935 (char *) "self",(char *) "sz", NULL
4936 };
4937
4938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4940 if (!SWIG_IsOK(res1)) {
4941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4942 }
4943 arg1 = reinterpret_cast< wxSize * >(argp1);
4944 {
4945 arg2 = &temp2;
4946 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4947 }
4948 {
4949 result = (arg1)->operator -((wxSize const &)*arg2);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4953 return resultobj;
4954 fail:
4955 return NULL;
4956 }
4957
4958
4959 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4960 PyObject *resultobj = 0;
4961 wxSize *arg1 = (wxSize *) 0 ;
4962 wxSize *arg2 = 0 ;
4963 void *argp1 = 0 ;
4964 int res1 = 0 ;
4965 wxSize temp2 ;
4966 PyObject * obj0 = 0 ;
4967 PyObject * obj1 = 0 ;
4968 char * kwnames[] = {
4969 (char *) "self",(char *) "sz", NULL
4970 };
4971
4972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4974 if (!SWIG_IsOK(res1)) {
4975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4976 }
4977 arg1 = reinterpret_cast< wxSize * >(argp1);
4978 {
4979 arg2 = &temp2;
4980 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4981 }
4982 {
4983 (arg1)->IncTo((wxSize const &)*arg2);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 resultobj = SWIG_Py_Void();
4987 return resultobj;
4988 fail:
4989 return NULL;
4990 }
4991
4992
4993 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4994 PyObject *resultobj = 0;
4995 wxSize *arg1 = (wxSize *) 0 ;
4996 wxSize *arg2 = 0 ;
4997 void *argp1 = 0 ;
4998 int res1 = 0 ;
4999 wxSize temp2 ;
5000 PyObject * obj0 = 0 ;
5001 PyObject * obj1 = 0 ;
5002 char * kwnames[] = {
5003 (char *) "self",(char *) "sz", NULL
5004 };
5005
5006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
5007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5008 if (!SWIG_IsOK(res1)) {
5009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
5010 }
5011 arg1 = reinterpret_cast< wxSize * >(argp1);
5012 {
5013 arg2 = &temp2;
5014 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5015 }
5016 {
5017 (arg1)->DecTo((wxSize const &)*arg2);
5018 if (PyErr_Occurred()) SWIG_fail;
5019 }
5020 resultobj = SWIG_Py_Void();
5021 return resultobj;
5022 fail:
5023 return NULL;
5024 }
5025
5026
5027 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5028 PyObject *resultobj = 0;
5029 wxSize *arg1 = (wxSize *) 0 ;
5030 int arg2 ;
5031 int arg3 ;
5032 void *argp1 = 0 ;
5033 int res1 = 0 ;
5034 int val2 ;
5035 int ecode2 = 0 ;
5036 int val3 ;
5037 int ecode3 = 0 ;
5038 PyObject * obj0 = 0 ;
5039 PyObject * obj1 = 0 ;
5040 PyObject * obj2 = 0 ;
5041 char * kwnames[] = {
5042 (char *) "self",(char *) "dx",(char *) "dy", NULL
5043 };
5044
5045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5047 if (!SWIG_IsOK(res1)) {
5048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5049 }
5050 arg1 = reinterpret_cast< wxSize * >(argp1);
5051 ecode2 = SWIG_AsVal_int(obj1, &val2);
5052 if (!SWIG_IsOK(ecode2)) {
5053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5054 }
5055 arg2 = static_cast< int >(val2);
5056 ecode3 = SWIG_AsVal_int(obj2, &val3);
5057 if (!SWIG_IsOK(ecode3)) {
5058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5059 }
5060 arg3 = static_cast< int >(val3);
5061 {
5062 (arg1)->IncBy(arg2,arg3);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 resultobj = SWIG_Py_Void();
5066 return resultobj;
5067 fail:
5068 return NULL;
5069 }
5070
5071
5072 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5073 PyObject *resultobj = 0;
5074 wxSize *arg1 = (wxSize *) 0 ;
5075 int arg2 ;
5076 int arg3 ;
5077 void *argp1 = 0 ;
5078 int res1 = 0 ;
5079 int val2 ;
5080 int ecode2 = 0 ;
5081 int val3 ;
5082 int ecode3 = 0 ;
5083 PyObject * obj0 = 0 ;
5084 PyObject * obj1 = 0 ;
5085 PyObject * obj2 = 0 ;
5086 char * kwnames[] = {
5087 (char *) "self",(char *) "dx",(char *) "dy", NULL
5088 };
5089
5090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5092 if (!SWIG_IsOK(res1)) {
5093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5094 }
5095 arg1 = reinterpret_cast< wxSize * >(argp1);
5096 ecode2 = SWIG_AsVal_int(obj1, &val2);
5097 if (!SWIG_IsOK(ecode2)) {
5098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5099 }
5100 arg2 = static_cast< int >(val2);
5101 ecode3 = SWIG_AsVal_int(obj2, &val3);
5102 if (!SWIG_IsOK(ecode3)) {
5103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5104 }
5105 arg3 = static_cast< int >(val3);
5106 {
5107 (arg1)->DecBy(arg2,arg3);
5108 if (PyErr_Occurred()) SWIG_fail;
5109 }
5110 resultobj = SWIG_Py_Void();
5111 return resultobj;
5112 fail:
5113 return NULL;
5114 }
5115
5116
5117 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5118 PyObject *resultobj = 0;
5119 wxSize *arg1 = (wxSize *) 0 ;
5120 float arg2 ;
5121 float arg3 ;
5122 void *argp1 = 0 ;
5123 int res1 = 0 ;
5124 float val2 ;
5125 int ecode2 = 0 ;
5126 float val3 ;
5127 int ecode3 = 0 ;
5128 PyObject * obj0 = 0 ;
5129 PyObject * obj1 = 0 ;
5130 PyObject * obj2 = 0 ;
5131 char * kwnames[] = {
5132 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5133 };
5134
5135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5137 if (!SWIG_IsOK(res1)) {
5138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5139 }
5140 arg1 = reinterpret_cast< wxSize * >(argp1);
5141 ecode2 = SWIG_AsVal_float(obj1, &val2);
5142 if (!SWIG_IsOK(ecode2)) {
5143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5144 }
5145 arg2 = static_cast< float >(val2);
5146 ecode3 = SWIG_AsVal_float(obj2, &val3);
5147 if (!SWIG_IsOK(ecode3)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5149 }
5150 arg3 = static_cast< float >(val3);
5151 {
5152 (arg1)->Scale(arg2,arg3);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 int arg2 ;
5166 int arg3 ;
5167 void *argp1 = 0 ;
5168 int res1 = 0 ;
5169 int val2 ;
5170 int ecode2 = 0 ;
5171 int val3 ;
5172 int ecode3 = 0 ;
5173 PyObject * obj0 = 0 ;
5174 PyObject * obj1 = 0 ;
5175 PyObject * obj2 = 0 ;
5176 char * kwnames[] = {
5177 (char *) "self",(char *) "w",(char *) "h", NULL
5178 };
5179
5180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5182 if (!SWIG_IsOK(res1)) {
5183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5184 }
5185 arg1 = reinterpret_cast< wxSize * >(argp1);
5186 ecode2 = SWIG_AsVal_int(obj1, &val2);
5187 if (!SWIG_IsOK(ecode2)) {
5188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5189 }
5190 arg2 = static_cast< int >(val2);
5191 ecode3 = SWIG_AsVal_int(obj2, &val3);
5192 if (!SWIG_IsOK(ecode3)) {
5193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5194 }
5195 arg3 = static_cast< int >(val3);
5196 {
5197 (arg1)->Set(arg2,arg3);
5198 if (PyErr_Occurred()) SWIG_fail;
5199 }
5200 resultobj = SWIG_Py_Void();
5201 return resultobj;
5202 fail:
5203 return NULL;
5204 }
5205
5206
5207 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5208 PyObject *resultobj = 0;
5209 wxSize *arg1 = (wxSize *) 0 ;
5210 int arg2 ;
5211 void *argp1 = 0 ;
5212 int res1 = 0 ;
5213 int val2 ;
5214 int ecode2 = 0 ;
5215 PyObject * obj0 = 0 ;
5216 PyObject * obj1 = 0 ;
5217 char * kwnames[] = {
5218 (char *) "self",(char *) "w", NULL
5219 };
5220
5221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5223 if (!SWIG_IsOK(res1)) {
5224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5225 }
5226 arg1 = reinterpret_cast< wxSize * >(argp1);
5227 ecode2 = SWIG_AsVal_int(obj1, &val2);
5228 if (!SWIG_IsOK(ecode2)) {
5229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5230 }
5231 arg2 = static_cast< int >(val2);
5232 {
5233 (arg1)->SetWidth(arg2);
5234 if (PyErr_Occurred()) SWIG_fail;
5235 }
5236 resultobj = SWIG_Py_Void();
5237 return resultobj;
5238 fail:
5239 return NULL;
5240 }
5241
5242
5243 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj = 0;
5245 wxSize *arg1 = (wxSize *) 0 ;
5246 int arg2 ;
5247 void *argp1 = 0 ;
5248 int res1 = 0 ;
5249 int val2 ;
5250 int ecode2 = 0 ;
5251 PyObject * obj0 = 0 ;
5252 PyObject * obj1 = 0 ;
5253 char * kwnames[] = {
5254 (char *) "self",(char *) "h", NULL
5255 };
5256
5257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5259 if (!SWIG_IsOK(res1)) {
5260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5261 }
5262 arg1 = reinterpret_cast< wxSize * >(argp1);
5263 ecode2 = SWIG_AsVal_int(obj1, &val2);
5264 if (!SWIG_IsOK(ecode2)) {
5265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5266 }
5267 arg2 = static_cast< int >(val2);
5268 {
5269 (arg1)->SetHeight(arg2);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 resultobj = SWIG_Py_Void();
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5280 PyObject *resultobj = 0;
5281 wxSize *arg1 = (wxSize *) 0 ;
5282 int result;
5283 void *argp1 = 0 ;
5284 int res1 = 0 ;
5285 PyObject *swig_obj[1] ;
5286
5287 if (!args) SWIG_fail;
5288 swig_obj[0] = args;
5289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5290 if (!SWIG_IsOK(res1)) {
5291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5292 }
5293 arg1 = reinterpret_cast< wxSize * >(argp1);
5294 {
5295 result = (int)((wxSize const *)arg1)->GetWidth();
5296 if (PyErr_Occurred()) SWIG_fail;
5297 }
5298 resultobj = SWIG_From_int(static_cast< int >(result));
5299 return resultobj;
5300 fail:
5301 return NULL;
5302 }
5303
5304
5305 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5306 PyObject *resultobj = 0;
5307 wxSize *arg1 = (wxSize *) 0 ;
5308 int result;
5309 void *argp1 = 0 ;
5310 int res1 = 0 ;
5311 PyObject *swig_obj[1] ;
5312
5313 if (!args) SWIG_fail;
5314 swig_obj[0] = args;
5315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5316 if (!SWIG_IsOK(res1)) {
5317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5318 }
5319 arg1 = reinterpret_cast< wxSize * >(argp1);
5320 {
5321 result = (int)((wxSize const *)arg1)->GetHeight();
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 resultobj = SWIG_From_int(static_cast< int >(result));
5325 return resultobj;
5326 fail:
5327 return NULL;
5328 }
5329
5330
5331 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5332 PyObject *resultobj = 0;
5333 wxSize *arg1 = (wxSize *) 0 ;
5334 bool result;
5335 void *argp1 = 0 ;
5336 int res1 = 0 ;
5337 PyObject *swig_obj[1] ;
5338
5339 if (!args) SWIG_fail;
5340 swig_obj[0] = args;
5341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5342 if (!SWIG_IsOK(res1)) {
5343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5344 }
5345 arg1 = reinterpret_cast< wxSize * >(argp1);
5346 {
5347 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 {
5351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5352 }
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5360 PyObject *resultobj = 0;
5361 wxSize *arg1 = (wxSize *) 0 ;
5362 wxSize *arg2 = 0 ;
5363 void *argp1 = 0 ;
5364 int res1 = 0 ;
5365 wxSize temp2 ;
5366 PyObject * obj0 = 0 ;
5367 PyObject * obj1 = 0 ;
5368 char * kwnames[] = {
5369 (char *) "self",(char *) "size", NULL
5370 };
5371
5372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5374 if (!SWIG_IsOK(res1)) {
5375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5376 }
5377 arg1 = reinterpret_cast< wxSize * >(argp1);
5378 {
5379 arg2 = &temp2;
5380 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5381 }
5382 {
5383 (arg1)->SetDefaults((wxSize const &)*arg2);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 resultobj = SWIG_Py_Void();
5387 return resultobj;
5388 fail:
5389 return NULL;
5390 }
5391
5392
5393 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5394 PyObject *resultobj = 0;
5395 wxSize *arg1 = (wxSize *) 0 ;
5396 PyObject *result = 0 ;
5397 void *argp1 = 0 ;
5398 int res1 = 0 ;
5399 PyObject *swig_obj[1] ;
5400
5401 if (!args) SWIG_fail;
5402 swig_obj[0] = args;
5403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5404 if (!SWIG_IsOK(res1)) {
5405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5406 }
5407 arg1 = reinterpret_cast< wxSize * >(argp1);
5408 {
5409 result = (PyObject *)wxSize_Get(arg1);
5410 if (PyErr_Occurred()) SWIG_fail;
5411 }
5412 resultobj = result;
5413 return resultobj;
5414 fail:
5415 return NULL;
5416 }
5417
5418
5419 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5420 PyObject *obj;
5421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5422 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5423 return SWIG_Py_Void();
5424 }
5425
5426 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5427 return SWIG_Python_InitShadowInstance(args);
5428 }
5429
5430 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5431 PyObject *resultobj = 0;
5432 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5433 double arg2 ;
5434 void *argp1 = 0 ;
5435 int res1 = 0 ;
5436 double val2 ;
5437 int ecode2 = 0 ;
5438 PyObject *swig_obj[2] ;
5439
5440 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5442 if (!SWIG_IsOK(res1)) {
5443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5444 }
5445 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5446 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5447 if (!SWIG_IsOK(ecode2)) {
5448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5449 }
5450 arg2 = static_cast< double >(val2);
5451 if (arg1) (arg1)->x = arg2;
5452
5453 resultobj = SWIG_Py_Void();
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5461 PyObject *resultobj = 0;
5462 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5463 double result;
5464 void *argp1 = 0 ;
5465 int res1 = 0 ;
5466 PyObject *swig_obj[1] ;
5467
5468 if (!args) SWIG_fail;
5469 swig_obj[0] = args;
5470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5471 if (!SWIG_IsOK(res1)) {
5472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5473 }
5474 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5475 result = (double) ((arg1)->x);
5476 resultobj = SWIG_From_double(static_cast< double >(result));
5477 return resultobj;
5478 fail:
5479 return NULL;
5480 }
5481
5482
5483 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5484 PyObject *resultobj = 0;
5485 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5486 double arg2 ;
5487 void *argp1 = 0 ;
5488 int res1 = 0 ;
5489 double val2 ;
5490 int ecode2 = 0 ;
5491 PyObject *swig_obj[2] ;
5492
5493 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5495 if (!SWIG_IsOK(res1)) {
5496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5497 }
5498 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5499 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5500 if (!SWIG_IsOK(ecode2)) {
5501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5502 }
5503 arg2 = static_cast< double >(val2);
5504 if (arg1) (arg1)->y = arg2;
5505
5506 resultobj = SWIG_Py_Void();
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5514 PyObject *resultobj = 0;
5515 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5516 double result;
5517 void *argp1 = 0 ;
5518 int res1 = 0 ;
5519 PyObject *swig_obj[1] ;
5520
5521 if (!args) SWIG_fail;
5522 swig_obj[0] = args;
5523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5524 if (!SWIG_IsOK(res1)) {
5525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5526 }
5527 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5528 result = (double) ((arg1)->y);
5529 resultobj = SWIG_From_double(static_cast< double >(result));
5530 return resultobj;
5531 fail:
5532 return NULL;
5533 }
5534
5535
5536 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5537 PyObject *resultobj = 0;
5538 double arg1 = (double) 0.0 ;
5539 double arg2 = (double) 0.0 ;
5540 wxRealPoint *result = 0 ;
5541 double val1 ;
5542 int ecode1 = 0 ;
5543 double val2 ;
5544 int ecode2 = 0 ;
5545 PyObject * obj0 = 0 ;
5546 PyObject * obj1 = 0 ;
5547 char * kwnames[] = {
5548 (char *) "x",(char *) "y", NULL
5549 };
5550
5551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5552 if (obj0) {
5553 ecode1 = SWIG_AsVal_double(obj0, &val1);
5554 if (!SWIG_IsOK(ecode1)) {
5555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5556 }
5557 arg1 = static_cast< double >(val1);
5558 }
5559 if (obj1) {
5560 ecode2 = SWIG_AsVal_double(obj1, &val2);
5561 if (!SWIG_IsOK(ecode2)) {
5562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5563 }
5564 arg2 = static_cast< double >(val2);
5565 }
5566 {
5567 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5578 PyObject *resultobj = 0;
5579 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5580 void *argp1 = 0 ;
5581 int res1 = 0 ;
5582 PyObject *swig_obj[1] ;
5583
5584 if (!args) SWIG_fail;
5585 swig_obj[0] = args;
5586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5587 if (!SWIG_IsOK(res1)) {
5588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5589 }
5590 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5591 {
5592 delete arg1;
5593
5594 if (PyErr_Occurred()) SWIG_fail;
5595 }
5596 resultobj = SWIG_Py_Void();
5597 return resultobj;
5598 fail:
5599 return NULL;
5600 }
5601
5602
5603 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5604 PyObject *resultobj = 0;
5605 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5606 PyObject *arg2 = (PyObject *) 0 ;
5607 bool result;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 PyObject * obj0 = 0 ;
5611 PyObject * obj1 = 0 ;
5612 char * kwnames[] = {
5613 (char *) "self",(char *) "other", NULL
5614 };
5615
5616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5618 if (!SWIG_IsOK(res1)) {
5619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5620 }
5621 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5622 arg2 = obj1;
5623 {
5624 result = (bool)wxRealPoint___eq__(arg1,arg2);
5625 if (PyErr_Occurred()) SWIG_fail;
5626 }
5627 {
5628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5629 }
5630 return resultobj;
5631 fail:
5632 return NULL;
5633 }
5634
5635
5636 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5637 PyObject *resultobj = 0;
5638 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5639 PyObject *arg2 = (PyObject *) 0 ;
5640 bool result;
5641 void *argp1 = 0 ;
5642 int res1 = 0 ;
5643 PyObject * obj0 = 0 ;
5644 PyObject * obj1 = 0 ;
5645 char * kwnames[] = {
5646 (char *) "self",(char *) "other", NULL
5647 };
5648
5649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5651 if (!SWIG_IsOK(res1)) {
5652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5653 }
5654 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5655 arg2 = obj1;
5656 {
5657 result = (bool)wxRealPoint___ne__(arg1,arg2);
5658 if (PyErr_Occurred()) SWIG_fail;
5659 }
5660 {
5661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5662 }
5663 return resultobj;
5664 fail:
5665 return NULL;
5666 }
5667
5668
5669 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5670 PyObject *resultobj = 0;
5671 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5672 wxRealPoint *arg2 = 0 ;
5673 wxRealPoint result;
5674 void *argp1 = 0 ;
5675 int res1 = 0 ;
5676 wxRealPoint temp2 ;
5677 PyObject * obj0 = 0 ;
5678 PyObject * obj1 = 0 ;
5679 char * kwnames[] = {
5680 (char *) "self",(char *) "pt", NULL
5681 };
5682
5683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5685 if (!SWIG_IsOK(res1)) {
5686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5687 }
5688 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5689 {
5690 arg2 = &temp2;
5691 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5692 }
5693 {
5694 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5695 if (PyErr_Occurred()) SWIG_fail;
5696 }
5697 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5698 return resultobj;
5699 fail:
5700 return NULL;
5701 }
5702
5703
5704 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5705 PyObject *resultobj = 0;
5706 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5707 wxRealPoint *arg2 = 0 ;
5708 wxRealPoint result;
5709 void *argp1 = 0 ;
5710 int res1 = 0 ;
5711 wxRealPoint temp2 ;
5712 PyObject * obj0 = 0 ;
5713 PyObject * obj1 = 0 ;
5714 char * kwnames[] = {
5715 (char *) "self",(char *) "pt", NULL
5716 };
5717
5718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5720 if (!SWIG_IsOK(res1)) {
5721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5722 }
5723 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5724 {
5725 arg2 = &temp2;
5726 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5727 }
5728 {
5729 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5730 if (PyErr_Occurred()) SWIG_fail;
5731 }
5732 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5733 return resultobj;
5734 fail:
5735 return NULL;
5736 }
5737
5738
5739 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5740 PyObject *resultobj = 0;
5741 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5742 double arg2 ;
5743 double arg3 ;
5744 void *argp1 = 0 ;
5745 int res1 = 0 ;
5746 double val2 ;
5747 int ecode2 = 0 ;
5748 double val3 ;
5749 int ecode3 = 0 ;
5750 PyObject * obj0 = 0 ;
5751 PyObject * obj1 = 0 ;
5752 PyObject * obj2 = 0 ;
5753 char * kwnames[] = {
5754 (char *) "self",(char *) "x",(char *) "y", NULL
5755 };
5756
5757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5759 if (!SWIG_IsOK(res1)) {
5760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5761 }
5762 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5763 ecode2 = SWIG_AsVal_double(obj1, &val2);
5764 if (!SWIG_IsOK(ecode2)) {
5765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5766 }
5767 arg2 = static_cast< double >(val2);
5768 ecode3 = SWIG_AsVal_double(obj2, &val3);
5769 if (!SWIG_IsOK(ecode3)) {
5770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5771 }
5772 arg3 = static_cast< double >(val3);
5773 {
5774 wxRealPoint_Set(arg1,arg2,arg3);
5775 if (PyErr_Occurred()) SWIG_fail;
5776 }
5777 resultobj = SWIG_Py_Void();
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5785 PyObject *resultobj = 0;
5786 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5787 PyObject *result = 0 ;
5788 void *argp1 = 0 ;
5789 int res1 = 0 ;
5790 PyObject *swig_obj[1] ;
5791
5792 if (!args) SWIG_fail;
5793 swig_obj[0] = args;
5794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5795 if (!SWIG_IsOK(res1)) {
5796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5797 }
5798 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5799 {
5800 result = (PyObject *)wxRealPoint_Get(arg1);
5801 if (PyErr_Occurred()) SWIG_fail;
5802 }
5803 resultobj = result;
5804 return resultobj;
5805 fail:
5806 return NULL;
5807 }
5808
5809
5810 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5811 PyObject *obj;
5812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5813 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5814 return SWIG_Py_Void();
5815 }
5816
5817 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5818 return SWIG_Python_InitShadowInstance(args);
5819 }
5820
5821 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5822 PyObject *resultobj = 0;
5823 wxPoint *arg1 = (wxPoint *) 0 ;
5824 int arg2 ;
5825 void *argp1 = 0 ;
5826 int res1 = 0 ;
5827 int val2 ;
5828 int ecode2 = 0 ;
5829 PyObject *swig_obj[2] ;
5830
5831 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5833 if (!SWIG_IsOK(res1)) {
5834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5835 }
5836 arg1 = reinterpret_cast< wxPoint * >(argp1);
5837 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5838 if (!SWIG_IsOK(ecode2)) {
5839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5840 }
5841 arg2 = static_cast< int >(val2);
5842 if (arg1) (arg1)->x = arg2;
5843
5844 resultobj = SWIG_Py_Void();
5845 return resultobj;
5846 fail:
5847 return NULL;
5848 }
5849
5850
5851 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5852 PyObject *resultobj = 0;
5853 wxPoint *arg1 = (wxPoint *) 0 ;
5854 int result;
5855 void *argp1 = 0 ;
5856 int res1 = 0 ;
5857 PyObject *swig_obj[1] ;
5858
5859 if (!args) SWIG_fail;
5860 swig_obj[0] = args;
5861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5862 if (!SWIG_IsOK(res1)) {
5863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5864 }
5865 arg1 = reinterpret_cast< wxPoint * >(argp1);
5866 result = (int) ((arg1)->x);
5867 resultobj = SWIG_From_int(static_cast< int >(result));
5868 return resultobj;
5869 fail:
5870 return NULL;
5871 }
5872
5873
5874 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5875 PyObject *resultobj = 0;
5876 wxPoint *arg1 = (wxPoint *) 0 ;
5877 int arg2 ;
5878 void *argp1 = 0 ;
5879 int res1 = 0 ;
5880 int val2 ;
5881 int ecode2 = 0 ;
5882 PyObject *swig_obj[2] ;
5883
5884 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5886 if (!SWIG_IsOK(res1)) {
5887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5888 }
5889 arg1 = reinterpret_cast< wxPoint * >(argp1);
5890 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5891 if (!SWIG_IsOK(ecode2)) {
5892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5893 }
5894 arg2 = static_cast< int >(val2);
5895 if (arg1) (arg1)->y = arg2;
5896
5897 resultobj = SWIG_Py_Void();
5898 return resultobj;
5899 fail:
5900 return NULL;
5901 }
5902
5903
5904 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5905 PyObject *resultobj = 0;
5906 wxPoint *arg1 = (wxPoint *) 0 ;
5907 int result;
5908 void *argp1 = 0 ;
5909 int res1 = 0 ;
5910 PyObject *swig_obj[1] ;
5911
5912 if (!args) SWIG_fail;
5913 swig_obj[0] = args;
5914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5915 if (!SWIG_IsOK(res1)) {
5916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5917 }
5918 arg1 = reinterpret_cast< wxPoint * >(argp1);
5919 result = (int) ((arg1)->y);
5920 resultobj = SWIG_From_int(static_cast< int >(result));
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj = 0;
5929 int arg1 = (int) 0 ;
5930 int arg2 = (int) 0 ;
5931 wxPoint *result = 0 ;
5932 int val1 ;
5933 int ecode1 = 0 ;
5934 int val2 ;
5935 int ecode2 = 0 ;
5936 PyObject * obj0 = 0 ;
5937 PyObject * obj1 = 0 ;
5938 char * kwnames[] = {
5939 (char *) "x",(char *) "y", NULL
5940 };
5941
5942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5943 if (obj0) {
5944 ecode1 = SWIG_AsVal_int(obj0, &val1);
5945 if (!SWIG_IsOK(ecode1)) {
5946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5947 }
5948 arg1 = static_cast< int >(val1);
5949 }
5950 if (obj1) {
5951 ecode2 = SWIG_AsVal_int(obj1, &val2);
5952 if (!SWIG_IsOK(ecode2)) {
5953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5954 }
5955 arg2 = static_cast< int >(val2);
5956 }
5957 {
5958 result = (wxPoint *)new wxPoint(arg1,arg2);
5959 if (PyErr_Occurred()) SWIG_fail;
5960 }
5961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5962 return resultobj;
5963 fail:
5964 return NULL;
5965 }
5966
5967
5968 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5969 PyObject *resultobj = 0;
5970 wxPoint *arg1 = (wxPoint *) 0 ;
5971 void *argp1 = 0 ;
5972 int res1 = 0 ;
5973 PyObject *swig_obj[1] ;
5974
5975 if (!args) SWIG_fail;
5976 swig_obj[0] = args;
5977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5978 if (!SWIG_IsOK(res1)) {
5979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5980 }
5981 arg1 = reinterpret_cast< wxPoint * >(argp1);
5982 {
5983 delete arg1;
5984
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 resultobj = SWIG_Py_Void();
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj = 0;
5996 wxPoint *arg1 = (wxPoint *) 0 ;
5997 PyObject *arg2 = (PyObject *) 0 ;
5998 bool result;
5999 void *argp1 = 0 ;
6000 int res1 = 0 ;
6001 PyObject * obj0 = 0 ;
6002 PyObject * obj1 = 0 ;
6003 char * kwnames[] = {
6004 (char *) "self",(char *) "other", NULL
6005 };
6006
6007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6009 if (!SWIG_IsOK(res1)) {
6010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
6011 }
6012 arg1 = reinterpret_cast< wxPoint * >(argp1);
6013 arg2 = obj1;
6014 {
6015 result = (bool)wxPoint___eq__(arg1,arg2);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 {
6019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6020 }
6021 return resultobj;
6022 fail:
6023 return NULL;
6024 }
6025
6026
6027 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6028 PyObject *resultobj = 0;
6029 wxPoint *arg1 = (wxPoint *) 0 ;
6030 PyObject *arg2 = (PyObject *) 0 ;
6031 bool result;
6032 void *argp1 = 0 ;
6033 int res1 = 0 ;
6034 PyObject * obj0 = 0 ;
6035 PyObject * obj1 = 0 ;
6036 char * kwnames[] = {
6037 (char *) "self",(char *) "other", NULL
6038 };
6039
6040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6042 if (!SWIG_IsOK(res1)) {
6043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6044 }
6045 arg1 = reinterpret_cast< wxPoint * >(argp1);
6046 arg2 = obj1;
6047 {
6048 result = (bool)wxPoint___ne__(arg1,arg2);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 {
6052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6053 }
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6061 PyObject *resultobj = 0;
6062 wxPoint *arg1 = (wxPoint *) 0 ;
6063 wxPoint *arg2 = 0 ;
6064 wxPoint result;
6065 void *argp1 = 0 ;
6066 int res1 = 0 ;
6067 wxPoint temp2 ;
6068 PyObject * obj0 = 0 ;
6069 PyObject * obj1 = 0 ;
6070 char * kwnames[] = {
6071 (char *) "self",(char *) "pt", NULL
6072 };
6073
6074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6076 if (!SWIG_IsOK(res1)) {
6077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6078 }
6079 arg1 = reinterpret_cast< wxPoint * >(argp1);
6080 {
6081 arg2 = &temp2;
6082 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6083 }
6084 {
6085 result = (arg1)->operator +((wxPoint const &)*arg2);
6086 if (PyErr_Occurred()) SWIG_fail;
6087 }
6088 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6089 return resultobj;
6090 fail:
6091 return NULL;
6092 }
6093
6094
6095 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6096 PyObject *resultobj = 0;
6097 wxPoint *arg1 = (wxPoint *) 0 ;
6098 wxPoint *arg2 = 0 ;
6099 wxPoint result;
6100 void *argp1 = 0 ;
6101 int res1 = 0 ;
6102 wxPoint temp2 ;
6103 PyObject * obj0 = 0 ;
6104 PyObject * obj1 = 0 ;
6105 char * kwnames[] = {
6106 (char *) "self",(char *) "pt", NULL
6107 };
6108
6109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6111 if (!SWIG_IsOK(res1)) {
6112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6113 }
6114 arg1 = reinterpret_cast< wxPoint * >(argp1);
6115 {
6116 arg2 = &temp2;
6117 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6118 }
6119 {
6120 result = (arg1)->operator -((wxPoint const &)*arg2);
6121 if (PyErr_Occurred()) SWIG_fail;
6122 }
6123 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6124 return resultobj;
6125 fail:
6126 return NULL;
6127 }
6128
6129
6130 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj = 0;
6132 wxPoint *arg1 = (wxPoint *) 0 ;
6133 wxPoint *arg2 = 0 ;
6134 wxPoint *result = 0 ;
6135 void *argp1 = 0 ;
6136 int res1 = 0 ;
6137 wxPoint temp2 ;
6138 PyObject * obj0 = 0 ;
6139 PyObject * obj1 = 0 ;
6140 char * kwnames[] = {
6141 (char *) "self",(char *) "pt", NULL
6142 };
6143
6144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6146 if (!SWIG_IsOK(res1)) {
6147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6148 }
6149 arg1 = reinterpret_cast< wxPoint * >(argp1);
6150 {
6151 arg2 = &temp2;
6152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6153 }
6154 {
6155 {
6156 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6157 result = (wxPoint *) &_result_ref;
6158 }
6159 if (PyErr_Occurred()) SWIG_fail;
6160 }
6161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6162 return resultobj;
6163 fail:
6164 return NULL;
6165 }
6166
6167
6168 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj = 0;
6170 wxPoint *arg1 = (wxPoint *) 0 ;
6171 wxPoint *arg2 = 0 ;
6172 wxPoint *result = 0 ;
6173 void *argp1 = 0 ;
6174 int res1 = 0 ;
6175 wxPoint temp2 ;
6176 PyObject * obj0 = 0 ;
6177 PyObject * obj1 = 0 ;
6178 char * kwnames[] = {
6179 (char *) "self",(char *) "pt", NULL
6180 };
6181
6182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6184 if (!SWIG_IsOK(res1)) {
6185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6186 }
6187 arg1 = reinterpret_cast< wxPoint * >(argp1);
6188 {
6189 arg2 = &temp2;
6190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6191 }
6192 {
6193 {
6194 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6195 result = (wxPoint *) &_result_ref;
6196 }
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 wxPoint *arg1 = (wxPoint *) 0 ;
6209 long arg2 ;
6210 long arg3 ;
6211 void *argp1 = 0 ;
6212 int res1 = 0 ;
6213 long val2 ;
6214 int ecode2 = 0 ;
6215 long val3 ;
6216 int ecode3 = 0 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 PyObject * obj2 = 0 ;
6220 char * kwnames[] = {
6221 (char *) "self",(char *) "x",(char *) "y", NULL
6222 };
6223
6224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6226 if (!SWIG_IsOK(res1)) {
6227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6228 }
6229 arg1 = reinterpret_cast< wxPoint * >(argp1);
6230 ecode2 = SWIG_AsVal_long(obj1, &val2);
6231 if (!SWIG_IsOK(ecode2)) {
6232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6233 }
6234 arg2 = static_cast< long >(val2);
6235 ecode3 = SWIG_AsVal_long(obj2, &val3);
6236 if (!SWIG_IsOK(ecode3)) {
6237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6238 }
6239 arg3 = static_cast< long >(val3);
6240 {
6241 wxPoint_Set(arg1,arg2,arg3);
6242 if (PyErr_Occurred()) SWIG_fail;
6243 }
6244 resultobj = SWIG_Py_Void();
6245 return resultobj;
6246 fail:
6247 return NULL;
6248 }
6249
6250
6251 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6252 PyObject *resultobj = 0;
6253 wxPoint *arg1 = (wxPoint *) 0 ;
6254 PyObject *result = 0 ;
6255 void *argp1 = 0 ;
6256 int res1 = 0 ;
6257 PyObject *swig_obj[1] ;
6258
6259 if (!args) SWIG_fail;
6260 swig_obj[0] = args;
6261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6262 if (!SWIG_IsOK(res1)) {
6263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6264 }
6265 arg1 = reinterpret_cast< wxPoint * >(argp1);
6266 {
6267 result = (PyObject *)wxPoint_Get(arg1);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 resultobj = result;
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6278 PyObject *obj;
6279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6280 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6281 return SWIG_Py_Void();
6282 }
6283
6284 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6285 return SWIG_Python_InitShadowInstance(args);
6286 }
6287
6288 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj = 0;
6290 int arg1 = (int) 0 ;
6291 int arg2 = (int) 0 ;
6292 int arg3 = (int) 0 ;
6293 int arg4 = (int) 0 ;
6294 wxRect *result = 0 ;
6295 int val1 ;
6296 int ecode1 = 0 ;
6297 int val2 ;
6298 int ecode2 = 0 ;
6299 int val3 ;
6300 int ecode3 = 0 ;
6301 int val4 ;
6302 int ecode4 = 0 ;
6303 PyObject * obj0 = 0 ;
6304 PyObject * obj1 = 0 ;
6305 PyObject * obj2 = 0 ;
6306 PyObject * obj3 = 0 ;
6307 char * kwnames[] = {
6308 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6309 };
6310
6311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6312 if (obj0) {
6313 ecode1 = SWIG_AsVal_int(obj0, &val1);
6314 if (!SWIG_IsOK(ecode1)) {
6315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6316 }
6317 arg1 = static_cast< int >(val1);
6318 }
6319 if (obj1) {
6320 ecode2 = SWIG_AsVal_int(obj1, &val2);
6321 if (!SWIG_IsOK(ecode2)) {
6322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6323 }
6324 arg2 = static_cast< int >(val2);
6325 }
6326 if (obj2) {
6327 ecode3 = SWIG_AsVal_int(obj2, &val3);
6328 if (!SWIG_IsOK(ecode3)) {
6329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6330 }
6331 arg3 = static_cast< int >(val3);
6332 }
6333 if (obj3) {
6334 ecode4 = SWIG_AsVal_int(obj3, &val4);
6335 if (!SWIG_IsOK(ecode4)) {
6336 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6337 }
6338 arg4 = static_cast< int >(val4);
6339 }
6340 {
6341 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6345 return resultobj;
6346 fail:
6347 return NULL;
6348 }
6349
6350
6351 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj = 0;
6353 wxPoint *arg1 = 0 ;
6354 wxPoint *arg2 = 0 ;
6355 wxRect *result = 0 ;
6356 wxPoint temp1 ;
6357 wxPoint temp2 ;
6358 PyObject * obj0 = 0 ;
6359 PyObject * obj1 = 0 ;
6360 char * kwnames[] = {
6361 (char *) "topLeft",(char *) "bottomRight", NULL
6362 };
6363
6364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6365 {
6366 arg1 = &temp1;
6367 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6368 }
6369 {
6370 arg2 = &temp2;
6371 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6372 }
6373 {
6374 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6375 if (PyErr_Occurred()) SWIG_fail;
6376 }
6377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6378 return resultobj;
6379 fail:
6380 return NULL;
6381 }
6382
6383
6384 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6385 PyObject *resultobj = 0;
6386 wxPoint *arg1 = 0 ;
6387 wxSize *arg2 = 0 ;
6388 wxRect *result = 0 ;
6389 wxPoint temp1 ;
6390 wxSize temp2 ;
6391 PyObject * obj0 = 0 ;
6392 PyObject * obj1 = 0 ;
6393 char * kwnames[] = {
6394 (char *) "pos",(char *) "size", NULL
6395 };
6396
6397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6398 {
6399 arg1 = &temp1;
6400 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6401 }
6402 {
6403 arg2 = &temp2;
6404 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6405 }
6406 {
6407 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj = 0;
6419 wxSize *arg1 = 0 ;
6420 wxRect *result = 0 ;
6421 wxSize temp1 ;
6422 PyObject * obj0 = 0 ;
6423 char * kwnames[] = {
6424 (char *) "size", NULL
6425 };
6426
6427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6428 {
6429 arg1 = &temp1;
6430 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6431 }
6432 {
6433 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6444 PyObject *resultobj = 0;
6445 wxRect *arg1 = (wxRect *) 0 ;
6446 void *argp1 = 0 ;
6447 int res1 = 0 ;
6448 PyObject *swig_obj[1] ;
6449
6450 if (!args) SWIG_fail;
6451 swig_obj[0] = args;
6452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6453 if (!SWIG_IsOK(res1)) {
6454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6455 }
6456 arg1 = reinterpret_cast< wxRect * >(argp1);
6457 {
6458 delete arg1;
6459
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 resultobj = SWIG_Py_Void();
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6470 PyObject *resultobj = 0;
6471 wxRect *arg1 = (wxRect *) 0 ;
6472 int result;
6473 void *argp1 = 0 ;
6474 int res1 = 0 ;
6475 PyObject *swig_obj[1] ;
6476
6477 if (!args) SWIG_fail;
6478 swig_obj[0] = args;
6479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6480 if (!SWIG_IsOK(res1)) {
6481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6482 }
6483 arg1 = reinterpret_cast< wxRect * >(argp1);
6484 {
6485 result = (int)((wxRect const *)arg1)->GetX();
6486 if (PyErr_Occurred()) SWIG_fail;
6487 }
6488 resultobj = SWIG_From_int(static_cast< int >(result));
6489 return resultobj;
6490 fail:
6491 return NULL;
6492 }
6493
6494
6495 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6496 PyObject *resultobj = 0;
6497 wxRect *arg1 = (wxRect *) 0 ;
6498 int arg2 ;
6499 void *argp1 = 0 ;
6500 int res1 = 0 ;
6501 int val2 ;
6502 int ecode2 = 0 ;
6503 PyObject * obj0 = 0 ;
6504 PyObject * obj1 = 0 ;
6505 char * kwnames[] = {
6506 (char *) "self",(char *) "x", NULL
6507 };
6508
6509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6511 if (!SWIG_IsOK(res1)) {
6512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6513 }
6514 arg1 = reinterpret_cast< wxRect * >(argp1);
6515 ecode2 = SWIG_AsVal_int(obj1, &val2);
6516 if (!SWIG_IsOK(ecode2)) {
6517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6518 }
6519 arg2 = static_cast< int >(val2);
6520 {
6521 (arg1)->SetX(arg2);
6522 if (PyErr_Occurred()) SWIG_fail;
6523 }
6524 resultobj = SWIG_Py_Void();
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6532 PyObject *resultobj = 0;
6533 wxRect *arg1 = (wxRect *) 0 ;
6534 int result;
6535 void *argp1 = 0 ;
6536 int res1 = 0 ;
6537 PyObject *swig_obj[1] ;
6538
6539 if (!args) SWIG_fail;
6540 swig_obj[0] = args;
6541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6542 if (!SWIG_IsOK(res1)) {
6543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6544 }
6545 arg1 = reinterpret_cast< wxRect * >(argp1);
6546 {
6547 result = (int)(arg1)->GetY();
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 resultobj = SWIG_From_int(static_cast< int >(result));
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj = 0;
6559 wxRect *arg1 = (wxRect *) 0 ;
6560 int arg2 ;
6561 void *argp1 = 0 ;
6562 int res1 = 0 ;
6563 int val2 ;
6564 int ecode2 = 0 ;
6565 PyObject * obj0 = 0 ;
6566 PyObject * obj1 = 0 ;
6567 char * kwnames[] = {
6568 (char *) "self",(char *) "y", NULL
6569 };
6570
6571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6573 if (!SWIG_IsOK(res1)) {
6574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6575 }
6576 arg1 = reinterpret_cast< wxRect * >(argp1);
6577 ecode2 = SWIG_AsVal_int(obj1, &val2);
6578 if (!SWIG_IsOK(ecode2)) {
6579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6580 }
6581 arg2 = static_cast< int >(val2);
6582 {
6583 (arg1)->SetY(arg2);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_Py_Void();
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6594 PyObject *resultobj = 0;
6595 wxRect *arg1 = (wxRect *) 0 ;
6596 int result;
6597 void *argp1 = 0 ;
6598 int res1 = 0 ;
6599 PyObject *swig_obj[1] ;
6600
6601 if (!args) SWIG_fail;
6602 swig_obj[0] = args;
6603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6604 if (!SWIG_IsOK(res1)) {
6605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6606 }
6607 arg1 = reinterpret_cast< wxRect * >(argp1);
6608 {
6609 result = (int)((wxRect const *)arg1)->GetWidth();
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 resultobj = SWIG_From_int(static_cast< int >(result));
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj = 0;
6621 wxRect *arg1 = (wxRect *) 0 ;
6622 int arg2 ;
6623 void *argp1 = 0 ;
6624 int res1 = 0 ;
6625 int val2 ;
6626 int ecode2 = 0 ;
6627 PyObject * obj0 = 0 ;
6628 PyObject * obj1 = 0 ;
6629 char * kwnames[] = {
6630 (char *) "self",(char *) "w", NULL
6631 };
6632
6633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6635 if (!SWIG_IsOK(res1)) {
6636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6637 }
6638 arg1 = reinterpret_cast< wxRect * >(argp1);
6639 ecode2 = SWIG_AsVal_int(obj1, &val2);
6640 if (!SWIG_IsOK(ecode2)) {
6641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6642 }
6643 arg2 = static_cast< int >(val2);
6644 {
6645 (arg1)->SetWidth(arg2);
6646 if (PyErr_Occurred()) SWIG_fail;
6647 }
6648 resultobj = SWIG_Py_Void();
6649 return resultobj;
6650 fail:
6651 return NULL;
6652 }
6653
6654
6655 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6656 PyObject *resultobj = 0;
6657 wxRect *arg1 = (wxRect *) 0 ;
6658 int result;
6659 void *argp1 = 0 ;
6660 int res1 = 0 ;
6661 PyObject *swig_obj[1] ;
6662
6663 if (!args) SWIG_fail;
6664 swig_obj[0] = args;
6665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6666 if (!SWIG_IsOK(res1)) {
6667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6668 }
6669 arg1 = reinterpret_cast< wxRect * >(argp1);
6670 {
6671 result = (int)((wxRect const *)arg1)->GetHeight();
6672 if (PyErr_Occurred()) SWIG_fail;
6673 }
6674 resultobj = SWIG_From_int(static_cast< int >(result));
6675 return resultobj;
6676 fail:
6677 return NULL;
6678 }
6679
6680
6681 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6682 PyObject *resultobj = 0;
6683 wxRect *arg1 = (wxRect *) 0 ;
6684 int arg2 ;
6685 void *argp1 = 0 ;
6686 int res1 = 0 ;
6687 int val2 ;
6688 int ecode2 = 0 ;
6689 PyObject * obj0 = 0 ;
6690 PyObject * obj1 = 0 ;
6691 char * kwnames[] = {
6692 (char *) "self",(char *) "h", NULL
6693 };
6694
6695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6697 if (!SWIG_IsOK(res1)) {
6698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6699 }
6700 arg1 = reinterpret_cast< wxRect * >(argp1);
6701 ecode2 = SWIG_AsVal_int(obj1, &val2);
6702 if (!SWIG_IsOK(ecode2)) {
6703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6704 }
6705 arg2 = static_cast< int >(val2);
6706 {
6707 (arg1)->SetHeight(arg2);
6708 if (PyErr_Occurred()) SWIG_fail;
6709 }
6710 resultobj = SWIG_Py_Void();
6711 return resultobj;
6712 fail:
6713 return NULL;
6714 }
6715
6716
6717 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6718 PyObject *resultobj = 0;
6719 wxRect *arg1 = (wxRect *) 0 ;
6720 wxPoint result;
6721 void *argp1 = 0 ;
6722 int res1 = 0 ;
6723 PyObject *swig_obj[1] ;
6724
6725 if (!args) SWIG_fail;
6726 swig_obj[0] = args;
6727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6728 if (!SWIG_IsOK(res1)) {
6729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6730 }
6731 arg1 = reinterpret_cast< wxRect * >(argp1);
6732 {
6733 result = ((wxRect const *)arg1)->GetPosition();
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj = 0;
6745 wxRect *arg1 = (wxRect *) 0 ;
6746 wxPoint *arg2 = 0 ;
6747 void *argp1 = 0 ;
6748 int res1 = 0 ;
6749 wxPoint temp2 ;
6750 PyObject * obj0 = 0 ;
6751 PyObject * obj1 = 0 ;
6752 char * kwnames[] = {
6753 (char *) "self",(char *) "p", NULL
6754 };
6755
6756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6758 if (!SWIG_IsOK(res1)) {
6759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6760 }
6761 arg1 = reinterpret_cast< wxRect * >(argp1);
6762 {
6763 arg2 = &temp2;
6764 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6765 }
6766 {
6767 (arg1)->SetPosition((wxPoint const &)*arg2);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 resultobj = SWIG_Py_Void();
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6778 PyObject *resultobj = 0;
6779 wxRect *arg1 = (wxRect *) 0 ;
6780 wxSize result;
6781 void *argp1 = 0 ;
6782 int res1 = 0 ;
6783 PyObject *swig_obj[1] ;
6784
6785 if (!args) SWIG_fail;
6786 swig_obj[0] = args;
6787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6788 if (!SWIG_IsOK(res1)) {
6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6790 }
6791 arg1 = reinterpret_cast< wxRect * >(argp1);
6792 {
6793 result = ((wxRect const *)arg1)->GetSize();
6794 if (PyErr_Occurred()) SWIG_fail;
6795 }
6796 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6797 return resultobj;
6798 fail:
6799 return NULL;
6800 }
6801
6802
6803 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6804 PyObject *resultobj = 0;
6805 wxRect *arg1 = (wxRect *) 0 ;
6806 wxSize *arg2 = 0 ;
6807 void *argp1 = 0 ;
6808 int res1 = 0 ;
6809 wxSize temp2 ;
6810 PyObject * obj0 = 0 ;
6811 PyObject * obj1 = 0 ;
6812 char * kwnames[] = {
6813 (char *) "self",(char *) "s", NULL
6814 };
6815
6816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6818 if (!SWIG_IsOK(res1)) {
6819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6820 }
6821 arg1 = reinterpret_cast< wxRect * >(argp1);
6822 {
6823 arg2 = &temp2;
6824 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6825 }
6826 {
6827 (arg1)->SetSize((wxSize const &)*arg2);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_Py_Void();
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 wxRect *arg1 = (wxRect *) 0 ;
6840 bool result;
6841 void *argp1 = 0 ;
6842 int res1 = 0 ;
6843 PyObject *swig_obj[1] ;
6844
6845 if (!args) SWIG_fail;
6846 swig_obj[0] = args;
6847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6848 if (!SWIG_IsOK(res1)) {
6849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6850 }
6851 arg1 = reinterpret_cast< wxRect * >(argp1);
6852 {
6853 result = (bool)((wxRect const *)arg1)->IsEmpty();
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 {
6857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6858 }
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6866 PyObject *resultobj = 0;
6867 wxRect *arg1 = (wxRect *) 0 ;
6868 wxPoint result;
6869 void *argp1 = 0 ;
6870 int res1 = 0 ;
6871 PyObject *swig_obj[1] ;
6872
6873 if (!args) SWIG_fail;
6874 swig_obj[0] = args;
6875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6876 if (!SWIG_IsOK(res1)) {
6877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6878 }
6879 arg1 = reinterpret_cast< wxRect * >(argp1);
6880 {
6881 result = ((wxRect const *)arg1)->GetTopLeft();
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6885 return resultobj;
6886 fail:
6887 return NULL;
6888 }
6889
6890
6891 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6892 PyObject *resultobj = 0;
6893 wxRect *arg1 = (wxRect *) 0 ;
6894 wxPoint *arg2 = 0 ;
6895 void *argp1 = 0 ;
6896 int res1 = 0 ;
6897 wxPoint temp2 ;
6898 PyObject * obj0 = 0 ;
6899 PyObject * obj1 = 0 ;
6900 char * kwnames[] = {
6901 (char *) "self",(char *) "p", NULL
6902 };
6903
6904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6906 if (!SWIG_IsOK(res1)) {
6907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6908 }
6909 arg1 = reinterpret_cast< wxRect * >(argp1);
6910 {
6911 arg2 = &temp2;
6912 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6913 }
6914 {
6915 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 resultobj = SWIG_Py_Void();
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6926 PyObject *resultobj = 0;
6927 wxRect *arg1 = (wxRect *) 0 ;
6928 wxPoint result;
6929 void *argp1 = 0 ;
6930 int res1 = 0 ;
6931 PyObject *swig_obj[1] ;
6932
6933 if (!args) SWIG_fail;
6934 swig_obj[0] = args;
6935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6936 if (!SWIG_IsOK(res1)) {
6937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6938 }
6939 arg1 = reinterpret_cast< wxRect * >(argp1);
6940 {
6941 result = ((wxRect const *)arg1)->GetBottomRight();
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6952 PyObject *resultobj = 0;
6953 wxRect *arg1 = (wxRect *) 0 ;
6954 wxPoint *arg2 = 0 ;
6955 void *argp1 = 0 ;
6956 int res1 = 0 ;
6957 wxPoint temp2 ;
6958 PyObject * obj0 = 0 ;
6959 PyObject * obj1 = 0 ;
6960 char * kwnames[] = {
6961 (char *) "self",(char *) "p", NULL
6962 };
6963
6964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6966 if (!SWIG_IsOK(res1)) {
6967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6968 }
6969 arg1 = reinterpret_cast< wxRect * >(argp1);
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 resultobj = SWIG_Py_Void();
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
6985 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6986 PyObject *resultobj = 0;
6987 wxRect *arg1 = (wxRect *) 0 ;
6988 wxPoint result;
6989 void *argp1 = 0 ;
6990 int res1 = 0 ;
6991 PyObject *swig_obj[1] ;
6992
6993 if (!args) SWIG_fail;
6994 swig_obj[0] = args;
6995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6996 if (!SWIG_IsOK(res1)) {
6997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6998 }
6999 arg1 = reinterpret_cast< wxRect * >(argp1);
7000 {
7001 result = ((wxRect const *)arg1)->GetTopRight();
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7012 PyObject *resultobj = 0;
7013 wxRect *arg1 = (wxRect *) 0 ;
7014 wxPoint *arg2 = 0 ;
7015 void *argp1 = 0 ;
7016 int res1 = 0 ;
7017 wxPoint temp2 ;
7018 PyObject * obj0 = 0 ;
7019 PyObject * obj1 = 0 ;
7020 char * kwnames[] = {
7021 (char *) "self",(char *) "p", NULL
7022 };
7023
7024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7026 if (!SWIG_IsOK(res1)) {
7027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7028 }
7029 arg1 = reinterpret_cast< wxRect * >(argp1);
7030 {
7031 arg2 = &temp2;
7032 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7033 }
7034 {
7035 (arg1)->SetTopRight((wxPoint const &)*arg2);
7036 if (PyErr_Occurred()) SWIG_fail;
7037 }
7038 resultobj = SWIG_Py_Void();
7039 return resultobj;
7040 fail:
7041 return NULL;
7042 }
7043
7044
7045 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7046 PyObject *resultobj = 0;
7047 wxRect *arg1 = (wxRect *) 0 ;
7048 wxPoint result;
7049 void *argp1 = 0 ;
7050 int res1 = 0 ;
7051 PyObject *swig_obj[1] ;
7052
7053 if (!args) SWIG_fail;
7054 swig_obj[0] = args;
7055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7056 if (!SWIG_IsOK(res1)) {
7057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7058 }
7059 arg1 = reinterpret_cast< wxRect * >(argp1);
7060 {
7061 result = ((wxRect const *)arg1)->GetBottomLeft();
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7065 return resultobj;
7066 fail:
7067 return NULL;
7068 }
7069
7070
7071 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7072 PyObject *resultobj = 0;
7073 wxRect *arg1 = (wxRect *) 0 ;
7074 wxPoint *arg2 = 0 ;
7075 void *argp1 = 0 ;
7076 int res1 = 0 ;
7077 wxPoint temp2 ;
7078 PyObject * obj0 = 0 ;
7079 PyObject * obj1 = 0 ;
7080 char * kwnames[] = {
7081 (char *) "self",(char *) "p", NULL
7082 };
7083
7084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7088 }
7089 arg1 = reinterpret_cast< wxRect * >(argp1);
7090 {
7091 arg2 = &temp2;
7092 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7093 }
7094 {
7095 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 resultobj = SWIG_Py_Void();
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7106 PyObject *resultobj = 0;
7107 wxRect *arg1 = (wxRect *) 0 ;
7108 int result;
7109 void *argp1 = 0 ;
7110 int res1 = 0 ;
7111 PyObject *swig_obj[1] ;
7112
7113 if (!args) SWIG_fail;
7114 swig_obj[0] = args;
7115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7116 if (!SWIG_IsOK(res1)) {
7117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7118 }
7119 arg1 = reinterpret_cast< wxRect * >(argp1);
7120 {
7121 result = (int)((wxRect const *)arg1)->GetLeft();
7122 if (PyErr_Occurred()) SWIG_fail;
7123 }
7124 resultobj = SWIG_From_int(static_cast< int >(result));
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7132 PyObject *resultobj = 0;
7133 wxRect *arg1 = (wxRect *) 0 ;
7134 int result;
7135 void *argp1 = 0 ;
7136 int res1 = 0 ;
7137 PyObject *swig_obj[1] ;
7138
7139 if (!args) SWIG_fail;
7140 swig_obj[0] = args;
7141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7142 if (!SWIG_IsOK(res1)) {
7143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7144 }
7145 arg1 = reinterpret_cast< wxRect * >(argp1);
7146 {
7147 result = (int)((wxRect const *)arg1)->GetTop();
7148 if (PyErr_Occurred()) SWIG_fail;
7149 }
7150 resultobj = SWIG_From_int(static_cast< int >(result));
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7158 PyObject *resultobj = 0;
7159 wxRect *arg1 = (wxRect *) 0 ;
7160 int result;
7161 void *argp1 = 0 ;
7162 int res1 = 0 ;
7163 PyObject *swig_obj[1] ;
7164
7165 if (!args) SWIG_fail;
7166 swig_obj[0] = args;
7167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7168 if (!SWIG_IsOK(res1)) {
7169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7170 }
7171 arg1 = reinterpret_cast< wxRect * >(argp1);
7172 {
7173 result = (int)((wxRect const *)arg1)->GetBottom();
7174 if (PyErr_Occurred()) SWIG_fail;
7175 }
7176 resultobj = SWIG_From_int(static_cast< int >(result));
7177 return resultobj;
7178 fail:
7179 return NULL;
7180 }
7181
7182
7183 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7184 PyObject *resultobj = 0;
7185 wxRect *arg1 = (wxRect *) 0 ;
7186 int result;
7187 void *argp1 = 0 ;
7188 int res1 = 0 ;
7189 PyObject *swig_obj[1] ;
7190
7191 if (!args) SWIG_fail;
7192 swig_obj[0] = args;
7193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7194 if (!SWIG_IsOK(res1)) {
7195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7196 }
7197 arg1 = reinterpret_cast< wxRect * >(argp1);
7198 {
7199 result = (int)((wxRect const *)arg1)->GetRight();
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 resultobj = SWIG_From_int(static_cast< int >(result));
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj = 0;
7211 wxRect *arg1 = (wxRect *) 0 ;
7212 int arg2 ;
7213 void *argp1 = 0 ;
7214 int res1 = 0 ;
7215 int val2 ;
7216 int ecode2 = 0 ;
7217 PyObject * obj0 = 0 ;
7218 PyObject * obj1 = 0 ;
7219 char * kwnames[] = {
7220 (char *) "self",(char *) "left", NULL
7221 };
7222
7223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7225 if (!SWIG_IsOK(res1)) {
7226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7227 }
7228 arg1 = reinterpret_cast< wxRect * >(argp1);
7229 ecode2 = SWIG_AsVal_int(obj1, &val2);
7230 if (!SWIG_IsOK(ecode2)) {
7231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7232 }
7233 arg2 = static_cast< int >(val2);
7234 {
7235 (arg1)->SetLeft(arg2);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 resultobj = SWIG_Py_Void();
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
7245 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7246 PyObject *resultobj = 0;
7247 wxRect *arg1 = (wxRect *) 0 ;
7248 int arg2 ;
7249 void *argp1 = 0 ;
7250 int res1 = 0 ;
7251 int val2 ;
7252 int ecode2 = 0 ;
7253 PyObject * obj0 = 0 ;
7254 PyObject * obj1 = 0 ;
7255 char * kwnames[] = {
7256 (char *) "self",(char *) "right", NULL
7257 };
7258
7259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7261 if (!SWIG_IsOK(res1)) {
7262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7263 }
7264 arg1 = reinterpret_cast< wxRect * >(argp1);
7265 ecode2 = SWIG_AsVal_int(obj1, &val2);
7266 if (!SWIG_IsOK(ecode2)) {
7267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7268 }
7269 arg2 = static_cast< int >(val2);
7270 {
7271 (arg1)->SetRight(arg2);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 resultobj = SWIG_Py_Void();
7275 return resultobj;
7276 fail:
7277 return NULL;
7278 }
7279
7280
7281 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7282 PyObject *resultobj = 0;
7283 wxRect *arg1 = (wxRect *) 0 ;
7284 int arg2 ;
7285 void *argp1 = 0 ;
7286 int res1 = 0 ;
7287 int val2 ;
7288 int ecode2 = 0 ;
7289 PyObject * obj0 = 0 ;
7290 PyObject * obj1 = 0 ;
7291 char * kwnames[] = {
7292 (char *) "self",(char *) "top", NULL
7293 };
7294
7295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7297 if (!SWIG_IsOK(res1)) {
7298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7299 }
7300 arg1 = reinterpret_cast< wxRect * >(argp1);
7301 ecode2 = SWIG_AsVal_int(obj1, &val2);
7302 if (!SWIG_IsOK(ecode2)) {
7303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7304 }
7305 arg2 = static_cast< int >(val2);
7306 {
7307 (arg1)->SetTop(arg2);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 resultobj = SWIG_Py_Void();
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj = 0;
7319 wxRect *arg1 = (wxRect *) 0 ;
7320 int arg2 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 int val2 ;
7324 int ecode2 = 0 ;
7325 PyObject * obj0 = 0 ;
7326 PyObject * obj1 = 0 ;
7327 char * kwnames[] = {
7328 (char *) "self",(char *) "bottom", NULL
7329 };
7330
7331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7333 if (!SWIG_IsOK(res1)) {
7334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7335 }
7336 arg1 = reinterpret_cast< wxRect * >(argp1);
7337 ecode2 = SWIG_AsVal_int(obj1, &val2);
7338 if (!SWIG_IsOK(ecode2)) {
7339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7340 }
7341 arg2 = static_cast< int >(val2);
7342 {
7343 (arg1)->SetBottom(arg2);
7344 if (PyErr_Occurred()) SWIG_fail;
7345 }
7346 resultobj = SWIG_Py_Void();
7347 return resultobj;
7348 fail:
7349 return NULL;
7350 }
7351
7352
7353 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7354 PyObject *resultobj = 0;
7355 wxRect *arg1 = (wxRect *) 0 ;
7356 int arg2 ;
7357 int arg3 ;
7358 wxRect result;
7359 void *argp1 = 0 ;
7360 int res1 = 0 ;
7361 int val2 ;
7362 int ecode2 = 0 ;
7363 int val3 ;
7364 int ecode3 = 0 ;
7365 PyObject * obj0 = 0 ;
7366 PyObject * obj1 = 0 ;
7367 PyObject * obj2 = 0 ;
7368 char * kwnames[] = {
7369 (char *) "self",(char *) "dx",(char *) "dy", NULL
7370 };
7371
7372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7374 if (!SWIG_IsOK(res1)) {
7375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7376 }
7377 arg1 = reinterpret_cast< wxRect * >(argp1);
7378 ecode2 = SWIG_AsVal_int(obj1, &val2);
7379 if (!SWIG_IsOK(ecode2)) {
7380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7381 }
7382 arg2 = static_cast< int >(val2);
7383 ecode3 = SWIG_AsVal_int(obj2, &val3);
7384 if (!SWIG_IsOK(ecode3)) {
7385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7386 }
7387 arg3 = static_cast< int >(val3);
7388 {
7389 result = (arg1)->Inflate(arg2,arg3);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj = 0;
7401 wxRect *arg1 = (wxRect *) 0 ;
7402 int arg2 ;
7403 int arg3 ;
7404 wxRect *result = 0 ;
7405 void *argp1 = 0 ;
7406 int res1 = 0 ;
7407 int val2 ;
7408 int ecode2 = 0 ;
7409 int val3 ;
7410 int ecode3 = 0 ;
7411 PyObject * obj0 = 0 ;
7412 PyObject * obj1 = 0 ;
7413 PyObject * obj2 = 0 ;
7414 char * kwnames[] = {
7415 (char *) "self",(char *) "dx",(char *) "dy", NULL
7416 };
7417
7418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7420 if (!SWIG_IsOK(res1)) {
7421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7422 }
7423 arg1 = reinterpret_cast< wxRect * >(argp1);
7424 ecode2 = SWIG_AsVal_int(obj1, &val2);
7425 if (!SWIG_IsOK(ecode2)) {
7426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7427 }
7428 arg2 = static_cast< int >(val2);
7429 ecode3 = SWIG_AsVal_int(obj2, &val3);
7430 if (!SWIG_IsOK(ecode3)) {
7431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7432 }
7433 arg3 = static_cast< int >(val3);
7434 {
7435 {
7436 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7437 result = (wxRect *) &_result_ref;
7438 }
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxRect *arg1 = (wxRect *) 0 ;
7451 int arg2 ;
7452 int arg3 ;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 int val2 ;
7456 int ecode2 = 0 ;
7457 int val3 ;
7458 int ecode3 = 0 ;
7459 PyObject * obj0 = 0 ;
7460 PyObject * obj1 = 0 ;
7461 PyObject * obj2 = 0 ;
7462 char * kwnames[] = {
7463 (char *) "self",(char *) "dx",(char *) "dy", NULL
7464 };
7465
7466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7468 if (!SWIG_IsOK(res1)) {
7469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7470 }
7471 arg1 = reinterpret_cast< wxRect * >(argp1);
7472 ecode2 = SWIG_AsVal_int(obj1, &val2);
7473 if (!SWIG_IsOK(ecode2)) {
7474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7475 }
7476 arg2 = static_cast< int >(val2);
7477 ecode3 = SWIG_AsVal_int(obj2, &val3);
7478 if (!SWIG_IsOK(ecode3)) {
7479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7480 }
7481 arg3 = static_cast< int >(val3);
7482 {
7483 (arg1)->Offset(arg2,arg3);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 resultobj = SWIG_Py_Void();
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj = 0;
7495 wxRect *arg1 = (wxRect *) 0 ;
7496 wxPoint *arg2 = 0 ;
7497 void *argp1 = 0 ;
7498 int res1 = 0 ;
7499 wxPoint temp2 ;
7500 PyObject * obj0 = 0 ;
7501 PyObject * obj1 = 0 ;
7502 char * kwnames[] = {
7503 (char *) "self",(char *) "pt", NULL
7504 };
7505
7506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7508 if (!SWIG_IsOK(res1)) {
7509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7510 }
7511 arg1 = reinterpret_cast< wxRect * >(argp1);
7512 {
7513 arg2 = &temp2;
7514 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7515 }
7516 {
7517 (arg1)->Offset((wxPoint const &)*arg2);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 resultobj = SWIG_Py_Void();
7521 return resultobj;
7522 fail:
7523 return NULL;
7524 }
7525
7526
7527 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7528 PyObject *resultobj = 0;
7529 wxRect *arg1 = (wxRect *) 0 ;
7530 wxRect *arg2 = 0 ;
7531 wxRect result;
7532 void *argp1 = 0 ;
7533 int res1 = 0 ;
7534 wxRect temp2 ;
7535 PyObject * obj0 = 0 ;
7536 PyObject * obj1 = 0 ;
7537 char * kwnames[] = {
7538 (char *) "self",(char *) "rect", NULL
7539 };
7540
7541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7543 if (!SWIG_IsOK(res1)) {
7544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7545 }
7546 arg1 = reinterpret_cast< wxRect * >(argp1);
7547 {
7548 arg2 = &temp2;
7549 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7550 }
7551 {
7552 result = (arg1)->Intersect((wxRect const &)*arg2);
7553 if (PyErr_Occurred()) SWIG_fail;
7554 }
7555 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7556 return resultobj;
7557 fail:
7558 return NULL;
7559 }
7560
7561
7562 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7563 PyObject *resultobj = 0;
7564 wxRect *arg1 = (wxRect *) 0 ;
7565 wxRect *arg2 = 0 ;
7566 wxRect result;
7567 void *argp1 = 0 ;
7568 int res1 = 0 ;
7569 wxRect temp2 ;
7570 PyObject * obj0 = 0 ;
7571 PyObject * obj1 = 0 ;
7572 char * kwnames[] = {
7573 (char *) "self",(char *) "rect", NULL
7574 };
7575
7576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7578 if (!SWIG_IsOK(res1)) {
7579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7580 }
7581 arg1 = reinterpret_cast< wxRect * >(argp1);
7582 {
7583 arg2 = &temp2;
7584 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7585 }
7586 {
7587 result = (arg1)->Union((wxRect const &)*arg2);
7588 if (PyErr_Occurred()) SWIG_fail;
7589 }
7590 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7591 return resultobj;
7592 fail:
7593 return NULL;
7594 }
7595
7596
7597 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7598 PyObject *resultobj = 0;
7599 wxRect *arg1 = (wxRect *) 0 ;
7600 wxRect *arg2 = 0 ;
7601 wxRect result;
7602 void *argp1 = 0 ;
7603 int res1 = 0 ;
7604 wxRect temp2 ;
7605 PyObject * obj0 = 0 ;
7606 PyObject * obj1 = 0 ;
7607 char * kwnames[] = {
7608 (char *) "self",(char *) "rect", NULL
7609 };
7610
7611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7613 if (!SWIG_IsOK(res1)) {
7614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7615 }
7616 arg1 = reinterpret_cast< wxRect * >(argp1);
7617 {
7618 arg2 = &temp2;
7619 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7620 }
7621 {
7622 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7623 if (PyErr_Occurred()) SWIG_fail;
7624 }
7625 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7633 PyObject *resultobj = 0;
7634 wxRect *arg1 = (wxRect *) 0 ;
7635 wxRect *arg2 = 0 ;
7636 wxRect *result = 0 ;
7637 void *argp1 = 0 ;
7638 int res1 = 0 ;
7639 wxRect temp2 ;
7640 PyObject * obj0 = 0 ;
7641 PyObject * obj1 = 0 ;
7642 char * kwnames[] = {
7643 (char *) "self",(char *) "rect", NULL
7644 };
7645
7646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7648 if (!SWIG_IsOK(res1)) {
7649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7650 }
7651 arg1 = reinterpret_cast< wxRect * >(argp1);
7652 {
7653 arg2 = &temp2;
7654 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7655 }
7656 {
7657 {
7658 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7659 result = (wxRect *) &_result_ref;
7660 }
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj = 0;
7672 wxRect *arg1 = (wxRect *) 0 ;
7673 PyObject *arg2 = (PyObject *) 0 ;
7674 bool result;
7675 void *argp1 = 0 ;
7676 int res1 = 0 ;
7677 PyObject * obj0 = 0 ;
7678 PyObject * obj1 = 0 ;
7679 char * kwnames[] = {
7680 (char *) "self",(char *) "other", NULL
7681 };
7682
7683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7685 if (!SWIG_IsOK(res1)) {
7686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7687 }
7688 arg1 = reinterpret_cast< wxRect * >(argp1);
7689 arg2 = obj1;
7690 {
7691 result = (bool)wxRect___eq__(arg1,arg2);
7692 if (PyErr_Occurred()) SWIG_fail;
7693 }
7694 {
7695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7696 }
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7704 PyObject *resultobj = 0;
7705 wxRect *arg1 = (wxRect *) 0 ;
7706 PyObject *arg2 = (PyObject *) 0 ;
7707 bool result;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 PyObject * obj0 = 0 ;
7711 PyObject * obj1 = 0 ;
7712 char * kwnames[] = {
7713 (char *) "self",(char *) "other", NULL
7714 };
7715
7716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7718 if (!SWIG_IsOK(res1)) {
7719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7720 }
7721 arg1 = reinterpret_cast< wxRect * >(argp1);
7722 arg2 = obj1;
7723 {
7724 result = (bool)wxRect___ne__(arg1,arg2);
7725 if (PyErr_Occurred()) SWIG_fail;
7726 }
7727 {
7728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7729 }
7730 return resultobj;
7731 fail:
7732 return NULL;
7733 }
7734
7735
7736 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7737 PyObject *resultobj = 0;
7738 wxRect *arg1 = (wxRect *) 0 ;
7739 int arg2 ;
7740 int arg3 ;
7741 bool result;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 int val2 ;
7745 int ecode2 = 0 ;
7746 int val3 ;
7747 int ecode3 = 0 ;
7748 PyObject * obj0 = 0 ;
7749 PyObject * obj1 = 0 ;
7750 PyObject * obj2 = 0 ;
7751 char * kwnames[] = {
7752 (char *) "self",(char *) "x",(char *) "y", NULL
7753 };
7754
7755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7757 if (!SWIG_IsOK(res1)) {
7758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7759 }
7760 arg1 = reinterpret_cast< wxRect * >(argp1);
7761 ecode2 = SWIG_AsVal_int(obj1, &val2);
7762 if (!SWIG_IsOK(ecode2)) {
7763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7764 }
7765 arg2 = static_cast< int >(val2);
7766 ecode3 = SWIG_AsVal_int(obj2, &val3);
7767 if (!SWIG_IsOK(ecode3)) {
7768 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7769 }
7770 arg3 = static_cast< int >(val3);
7771 {
7772 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 {
7776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7777 }
7778 return resultobj;
7779 fail:
7780 return NULL;
7781 }
7782
7783
7784 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj = 0;
7786 wxRect *arg1 = (wxRect *) 0 ;
7787 wxPoint *arg2 = 0 ;
7788 bool result;
7789 void *argp1 = 0 ;
7790 int res1 = 0 ;
7791 wxPoint temp2 ;
7792 PyObject * obj0 = 0 ;
7793 PyObject * obj1 = 0 ;
7794 char * kwnames[] = {
7795 (char *) "self",(char *) "pt", NULL
7796 };
7797
7798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7800 if (!SWIG_IsOK(res1)) {
7801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7802 }
7803 arg1 = reinterpret_cast< wxRect * >(argp1);
7804 {
7805 arg2 = &temp2;
7806 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7807 }
7808 {
7809 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 {
7813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7814 }
7815 return resultobj;
7816 fail:
7817 return NULL;
7818 }
7819
7820
7821 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7822 PyObject *resultobj = 0;
7823 wxRect *arg1 = (wxRect *) 0 ;
7824 wxRect *arg2 = 0 ;
7825 bool result;
7826 void *argp1 = 0 ;
7827 int res1 = 0 ;
7828 wxRect temp2 ;
7829 PyObject * obj0 = 0 ;
7830 PyObject * obj1 = 0 ;
7831 char * kwnames[] = {
7832 (char *) "self",(char *) "rect", NULL
7833 };
7834
7835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7837 if (!SWIG_IsOK(res1)) {
7838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7839 }
7840 arg1 = reinterpret_cast< wxRect * >(argp1);
7841 {
7842 arg2 = &temp2;
7843 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7844 }
7845 {
7846 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7847 if (PyErr_Occurred()) SWIG_fail;
7848 }
7849 {
7850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7851 }
7852 return resultobj;
7853 fail:
7854 return NULL;
7855 }
7856
7857
7858 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7859 PyObject *resultobj = 0;
7860 wxRect *arg1 = (wxRect *) 0 ;
7861 wxRect *arg2 = 0 ;
7862 bool result;
7863 void *argp1 = 0 ;
7864 int res1 = 0 ;
7865 wxRect temp2 ;
7866 PyObject * obj0 = 0 ;
7867 PyObject * obj1 = 0 ;
7868 char * kwnames[] = {
7869 (char *) "self",(char *) "rect", NULL
7870 };
7871
7872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7874 if (!SWIG_IsOK(res1)) {
7875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7876 }
7877 arg1 = reinterpret_cast< wxRect * >(argp1);
7878 {
7879 arg2 = &temp2;
7880 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7881 }
7882 {
7883 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7884 if (PyErr_Occurred()) SWIG_fail;
7885 }
7886 {
7887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7888 }
7889 return resultobj;
7890 fail:
7891 return NULL;
7892 }
7893
7894
7895 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7896 PyObject *resultobj = 0;
7897 wxRect *arg1 = (wxRect *) 0 ;
7898 wxRect *arg2 = 0 ;
7899 int arg3 = (int) wxBOTH ;
7900 wxRect result;
7901 void *argp1 = 0 ;
7902 int res1 = 0 ;
7903 wxRect temp2 ;
7904 int val3 ;
7905 int ecode3 = 0 ;
7906 PyObject * obj0 = 0 ;
7907 PyObject * obj1 = 0 ;
7908 PyObject * obj2 = 0 ;
7909 char * kwnames[] = {
7910 (char *) "self",(char *) "r",(char *) "dir", NULL
7911 };
7912
7913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7915 if (!SWIG_IsOK(res1)) {
7916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7917 }
7918 arg1 = reinterpret_cast< wxRect * >(argp1);
7919 {
7920 arg2 = &temp2;
7921 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7922 }
7923 if (obj2) {
7924 ecode3 = SWIG_AsVal_int(obj2, &val3);
7925 if (!SWIG_IsOK(ecode3)) {
7926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7927 }
7928 arg3 = static_cast< int >(val3);
7929 }
7930 {
7931 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7942 PyObject *resultobj = 0;
7943 wxRect *arg1 = (wxRect *) 0 ;
7944 int arg2 ;
7945 void *argp1 = 0 ;
7946 int res1 = 0 ;
7947 int val2 ;
7948 int ecode2 = 0 ;
7949 PyObject *swig_obj[2] ;
7950
7951 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7953 if (!SWIG_IsOK(res1)) {
7954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7955 }
7956 arg1 = reinterpret_cast< wxRect * >(argp1);
7957 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7958 if (!SWIG_IsOK(ecode2)) {
7959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7960 }
7961 arg2 = static_cast< int >(val2);
7962 if (arg1) (arg1)->x = arg2;
7963
7964 resultobj = SWIG_Py_Void();
7965 return resultobj;
7966 fail:
7967 return NULL;
7968 }
7969
7970
7971 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7972 PyObject *resultobj = 0;
7973 wxRect *arg1 = (wxRect *) 0 ;
7974 int result;
7975 void *argp1 = 0 ;
7976 int res1 = 0 ;
7977 PyObject *swig_obj[1] ;
7978
7979 if (!args) SWIG_fail;
7980 swig_obj[0] = args;
7981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7982 if (!SWIG_IsOK(res1)) {
7983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7984 }
7985 arg1 = reinterpret_cast< wxRect * >(argp1);
7986 result = (int) ((arg1)->x);
7987 resultobj = SWIG_From_int(static_cast< int >(result));
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7995 PyObject *resultobj = 0;
7996 wxRect *arg1 = (wxRect *) 0 ;
7997 int arg2 ;
7998 void *argp1 = 0 ;
7999 int res1 = 0 ;
8000 int val2 ;
8001 int ecode2 = 0 ;
8002 PyObject *swig_obj[2] ;
8003
8004 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
8005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8006 if (!SWIG_IsOK(res1)) {
8007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8008 }
8009 arg1 = reinterpret_cast< wxRect * >(argp1);
8010 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8011 if (!SWIG_IsOK(ecode2)) {
8012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8013 }
8014 arg2 = static_cast< int >(val2);
8015 if (arg1) (arg1)->y = arg2;
8016
8017 resultobj = SWIG_Py_Void();
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 PyObject *resultobj = 0;
8026 wxRect *arg1 = (wxRect *) 0 ;
8027 int result;
8028 void *argp1 = 0 ;
8029 int res1 = 0 ;
8030 PyObject *swig_obj[1] ;
8031
8032 if (!args) SWIG_fail;
8033 swig_obj[0] = args;
8034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8035 if (!SWIG_IsOK(res1)) {
8036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8037 }
8038 arg1 = reinterpret_cast< wxRect * >(argp1);
8039 result = (int) ((arg1)->y);
8040 resultobj = SWIG_From_int(static_cast< int >(result));
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8048 PyObject *resultobj = 0;
8049 wxRect *arg1 = (wxRect *) 0 ;
8050 int arg2 ;
8051 void *argp1 = 0 ;
8052 int res1 = 0 ;
8053 int val2 ;
8054 int ecode2 = 0 ;
8055 PyObject *swig_obj[2] ;
8056
8057 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8059 if (!SWIG_IsOK(res1)) {
8060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8061 }
8062 arg1 = reinterpret_cast< wxRect * >(argp1);
8063 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8064 if (!SWIG_IsOK(ecode2)) {
8065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8066 }
8067 arg2 = static_cast< int >(val2);
8068 if (arg1) (arg1)->width = arg2;
8069
8070 resultobj = SWIG_Py_Void();
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079 wxRect *arg1 = (wxRect *) 0 ;
8080 int result;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 PyObject *swig_obj[1] ;
8084
8085 if (!args) SWIG_fail;
8086 swig_obj[0] = args;
8087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8088 if (!SWIG_IsOK(res1)) {
8089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8090 }
8091 arg1 = reinterpret_cast< wxRect * >(argp1);
8092 result = (int) ((arg1)->width);
8093 resultobj = SWIG_From_int(static_cast< int >(result));
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8101 PyObject *resultobj = 0;
8102 wxRect *arg1 = (wxRect *) 0 ;
8103 int arg2 ;
8104 void *argp1 = 0 ;
8105 int res1 = 0 ;
8106 int val2 ;
8107 int ecode2 = 0 ;
8108 PyObject *swig_obj[2] ;
8109
8110 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8112 if (!SWIG_IsOK(res1)) {
8113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8114 }
8115 arg1 = reinterpret_cast< wxRect * >(argp1);
8116 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8117 if (!SWIG_IsOK(ecode2)) {
8118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8119 }
8120 arg2 = static_cast< int >(val2);
8121 if (arg1) (arg1)->height = arg2;
8122
8123 resultobj = SWIG_Py_Void();
8124 return resultobj;
8125 fail:
8126 return NULL;
8127 }
8128
8129
8130 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8131 PyObject *resultobj = 0;
8132 wxRect *arg1 = (wxRect *) 0 ;
8133 int result;
8134 void *argp1 = 0 ;
8135 int res1 = 0 ;
8136 PyObject *swig_obj[1] ;
8137
8138 if (!args) SWIG_fail;
8139 swig_obj[0] = args;
8140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8141 if (!SWIG_IsOK(res1)) {
8142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8143 }
8144 arg1 = reinterpret_cast< wxRect * >(argp1);
8145 result = (int) ((arg1)->height);
8146 resultobj = SWIG_From_int(static_cast< int >(result));
8147 return resultobj;
8148 fail:
8149 return NULL;
8150 }
8151
8152
8153 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8154 PyObject *resultobj = 0;
8155 wxRect *arg1 = (wxRect *) 0 ;
8156 int arg2 = (int) 0 ;
8157 int arg3 = (int) 0 ;
8158 int arg4 = (int) 0 ;
8159 int arg5 = (int) 0 ;
8160 void *argp1 = 0 ;
8161 int res1 = 0 ;
8162 int val2 ;
8163 int ecode2 = 0 ;
8164 int val3 ;
8165 int ecode3 = 0 ;
8166 int val4 ;
8167 int ecode4 = 0 ;
8168 int val5 ;
8169 int ecode5 = 0 ;
8170 PyObject * obj0 = 0 ;
8171 PyObject * obj1 = 0 ;
8172 PyObject * obj2 = 0 ;
8173 PyObject * obj3 = 0 ;
8174 PyObject * obj4 = 0 ;
8175 char * kwnames[] = {
8176 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8177 };
8178
8179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8181 if (!SWIG_IsOK(res1)) {
8182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8183 }
8184 arg1 = reinterpret_cast< wxRect * >(argp1);
8185 if (obj1) {
8186 ecode2 = SWIG_AsVal_int(obj1, &val2);
8187 if (!SWIG_IsOK(ecode2)) {
8188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8189 }
8190 arg2 = static_cast< int >(val2);
8191 }
8192 if (obj2) {
8193 ecode3 = SWIG_AsVal_int(obj2, &val3);
8194 if (!SWIG_IsOK(ecode3)) {
8195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8196 }
8197 arg3 = static_cast< int >(val3);
8198 }
8199 if (obj3) {
8200 ecode4 = SWIG_AsVal_int(obj3, &val4);
8201 if (!SWIG_IsOK(ecode4)) {
8202 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8203 }
8204 arg4 = static_cast< int >(val4);
8205 }
8206 if (obj4) {
8207 ecode5 = SWIG_AsVal_int(obj4, &val5);
8208 if (!SWIG_IsOK(ecode5)) {
8209 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8210 }
8211 arg5 = static_cast< int >(val5);
8212 }
8213 {
8214 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8215 if (PyErr_Occurred()) SWIG_fail;
8216 }
8217 resultobj = SWIG_Py_Void();
8218 return resultobj;
8219 fail:
8220 return NULL;
8221 }
8222
8223
8224 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8225 PyObject *resultobj = 0;
8226 wxRect *arg1 = (wxRect *) 0 ;
8227 PyObject *result = 0 ;
8228 void *argp1 = 0 ;
8229 int res1 = 0 ;
8230 PyObject *swig_obj[1] ;
8231
8232 if (!args) SWIG_fail;
8233 swig_obj[0] = args;
8234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8235 if (!SWIG_IsOK(res1)) {
8236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8237 }
8238 arg1 = reinterpret_cast< wxRect * >(argp1);
8239 {
8240 result = (PyObject *)wxRect_Get(arg1);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 resultobj = result;
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8251 PyObject *obj;
8252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8253 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8254 return SWIG_Py_Void();
8255 }
8256
8257 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8258 return SWIG_Python_InitShadowInstance(args);
8259 }
8260
8261 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8262 PyObject *resultobj = 0;
8263 wxRect *arg1 = (wxRect *) 0 ;
8264 wxRect *arg2 = (wxRect *) 0 ;
8265 PyObject *result = 0 ;
8266 void *argp1 = 0 ;
8267 int res1 = 0 ;
8268 void *argp2 = 0 ;
8269 int res2 = 0 ;
8270 PyObject * obj0 = 0 ;
8271 PyObject * obj1 = 0 ;
8272 char * kwnames[] = {
8273 (char *) "r1",(char *) "r2", NULL
8274 };
8275
8276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8278 if (!SWIG_IsOK(res1)) {
8279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8280 }
8281 arg1 = reinterpret_cast< wxRect * >(argp1);
8282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8283 if (!SWIG_IsOK(res2)) {
8284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8285 }
8286 arg2 = reinterpret_cast< wxRect * >(argp2);
8287 {
8288 if (!wxPyCheckForApp()) SWIG_fail;
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 result = (PyObject *)wxIntersectRect(arg1,arg2);
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 resultobj = result;
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8302 PyObject *resultobj = 0;
8303 double arg1 = (double) 0.0 ;
8304 double arg2 = (double) 0.0 ;
8305 wxPoint2D *result = 0 ;
8306 double val1 ;
8307 int ecode1 = 0 ;
8308 double val2 ;
8309 int ecode2 = 0 ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 char * kwnames[] = {
8313 (char *) "x",(char *) "y", NULL
8314 };
8315
8316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8317 if (obj0) {
8318 ecode1 = SWIG_AsVal_double(obj0, &val1);
8319 if (!SWIG_IsOK(ecode1)) {
8320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8321 }
8322 arg1 = static_cast< double >(val1);
8323 }
8324 if (obj1) {
8325 ecode2 = SWIG_AsVal_double(obj1, &val2);
8326 if (!SWIG_IsOK(ecode2)) {
8327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8328 }
8329 arg2 = static_cast< double >(val2);
8330 }
8331 {
8332 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8343 PyObject *resultobj = 0;
8344 wxPoint2D *arg1 = 0 ;
8345 wxPoint2D *result = 0 ;
8346 wxPoint2D temp1 ;
8347 PyObject * obj0 = 0 ;
8348 char * kwnames[] = {
8349 (char *) "pt", NULL
8350 };
8351
8352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8353 {
8354 arg1 = &temp1;
8355 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8356 }
8357 {
8358 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj = 0;
8370 wxPoint *arg1 = 0 ;
8371 wxPoint2D *result = 0 ;
8372 wxPoint temp1 ;
8373 PyObject * obj0 = 0 ;
8374 char * kwnames[] = {
8375 (char *) "pt", NULL
8376 };
8377
8378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8379 {
8380 arg1 = &temp1;
8381 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8382 }
8383 {
8384 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8385 if (PyErr_Occurred()) SWIG_fail;
8386 }
8387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8388 return resultobj;
8389 fail:
8390 return NULL;
8391 }
8392
8393
8394 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8395 PyObject *resultobj = 0;
8396 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8397 void *argp1 = 0 ;
8398 int res1 = 0 ;
8399 PyObject *swig_obj[1] ;
8400
8401 if (!args) SWIG_fail;
8402 swig_obj[0] = args;
8403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8404 if (!SWIG_IsOK(res1)) {
8405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8406 }
8407 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8408 {
8409 delete arg1;
8410
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_Py_Void();
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8421 PyObject *resultobj = 0;
8422 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8423 int *arg2 = (int *) 0 ;
8424 int *arg3 = (int *) 0 ;
8425 void *argp1 = 0 ;
8426 int res1 = 0 ;
8427 int temp2 ;
8428 int res2 = SWIG_TMPOBJ ;
8429 int temp3 ;
8430 int res3 = SWIG_TMPOBJ ;
8431 PyObject *swig_obj[1] ;
8432
8433 arg2 = &temp2;
8434 arg3 = &temp3;
8435 if (!args) SWIG_fail;
8436 swig_obj[0] = args;
8437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8438 if (!SWIG_IsOK(res1)) {
8439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8440 }
8441 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8442 {
8443 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8444 if (PyErr_Occurred()) SWIG_fail;
8445 }
8446 resultobj = SWIG_Py_Void();
8447 if (SWIG_IsTmpObj(res2)) {
8448 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8449 } else {
8450 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8451 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8452 }
8453 if (SWIG_IsTmpObj(res3)) {
8454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8455 } else {
8456 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8458 }
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8466 PyObject *resultobj = 0;
8467 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8468 int *arg2 = (int *) 0 ;
8469 int *arg3 = (int *) 0 ;
8470 void *argp1 = 0 ;
8471 int res1 = 0 ;
8472 int temp2 ;
8473 int res2 = SWIG_TMPOBJ ;
8474 int temp3 ;
8475 int res3 = SWIG_TMPOBJ ;
8476 PyObject *swig_obj[1] ;
8477
8478 arg2 = &temp2;
8479 arg3 = &temp3;
8480 if (!args) SWIG_fail;
8481 swig_obj[0] = args;
8482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8483 if (!SWIG_IsOK(res1)) {
8484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8485 }
8486 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8487 {
8488 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 resultobj = SWIG_Py_Void();
8492 if (SWIG_IsTmpObj(res2)) {
8493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8494 } else {
8495 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8497 }
8498 if (SWIG_IsTmpObj(res3)) {
8499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8500 } else {
8501 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8503 }
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8511 PyObject *resultobj = 0;
8512 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8513 double result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 PyObject *swig_obj[1] ;
8517
8518 if (!args) SWIG_fail;
8519 swig_obj[0] = args;
8520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8521 if (!SWIG_IsOK(res1)) {
8522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8523 }
8524 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8525 {
8526 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 resultobj = SWIG_From_double(static_cast< double >(result));
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8537 PyObject *resultobj = 0;
8538 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8539 double result;
8540 void *argp1 = 0 ;
8541 int res1 = 0 ;
8542 PyObject *swig_obj[1] ;
8543
8544 if (!args) SWIG_fail;
8545 swig_obj[0] = args;
8546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8547 if (!SWIG_IsOK(res1)) {
8548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8549 }
8550 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8551 {
8552 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8553 if (PyErr_Occurred()) SWIG_fail;
8554 }
8555 resultobj = SWIG_From_double(static_cast< double >(result));
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8563 PyObject *resultobj = 0;
8564 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8565 double arg2 ;
8566 void *argp1 = 0 ;
8567 int res1 = 0 ;
8568 double val2 ;
8569 int ecode2 = 0 ;
8570 PyObject * obj0 = 0 ;
8571 PyObject * obj1 = 0 ;
8572 char * kwnames[] = {
8573 (char *) "self",(char *) "length", NULL
8574 };
8575
8576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8578 if (!SWIG_IsOK(res1)) {
8579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8580 }
8581 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8582 ecode2 = SWIG_AsVal_double(obj1, &val2);
8583 if (!SWIG_IsOK(ecode2)) {
8584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8585 }
8586 arg2 = static_cast< double >(val2);
8587 {
8588 (arg1)->SetVectorLength(arg2);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_Py_Void();
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj = 0;
8600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8601 double arg2 ;
8602 void *argp1 = 0 ;
8603 int res1 = 0 ;
8604 double val2 ;
8605 int ecode2 = 0 ;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 char * kwnames[] = {
8609 (char *) "self",(char *) "degrees", NULL
8610 };
8611
8612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8616 }
8617 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8618 ecode2 = SWIG_AsVal_double(obj1, &val2);
8619 if (!SWIG_IsOK(ecode2)) {
8620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8621 }
8622 arg2 = static_cast< double >(val2);
8623 {
8624 (arg1)->SetVectorAngle(arg2);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 resultobj = SWIG_Py_Void();
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj = 0;
8636 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8637 wxPoint2D *arg2 = 0 ;
8638 double result;
8639 void *argp1 = 0 ;
8640 int res1 = 0 ;
8641 wxPoint2D temp2 ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char * kwnames[] = {
8645 (char *) "self",(char *) "pt", NULL
8646 };
8647
8648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8650 if (!SWIG_IsOK(res1)) {
8651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8652 }
8653 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8654 {
8655 arg2 = &temp2;
8656 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8657 }
8658 {
8659 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 resultobj = SWIG_From_double(static_cast< double >(result));
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8670 PyObject *resultobj = 0;
8671 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8672 wxPoint2D *arg2 = 0 ;
8673 double result;
8674 void *argp1 = 0 ;
8675 int res1 = 0 ;
8676 wxPoint2D temp2 ;
8677 PyObject * obj0 = 0 ;
8678 PyObject * obj1 = 0 ;
8679 char * kwnames[] = {
8680 (char *) "self",(char *) "pt", NULL
8681 };
8682
8683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8685 if (!SWIG_IsOK(res1)) {
8686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8687 }
8688 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8689 {
8690 arg2 = &temp2;
8691 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8692 }
8693 {
8694 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 resultobj = SWIG_From_double(static_cast< double >(result));
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8705 PyObject *resultobj = 0;
8706 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8707 wxPoint2D *arg2 = 0 ;
8708 double result;
8709 void *argp1 = 0 ;
8710 int res1 = 0 ;
8711 wxPoint2D temp2 ;
8712 PyObject * obj0 = 0 ;
8713 PyObject * obj1 = 0 ;
8714 char * kwnames[] = {
8715 (char *) "self",(char *) "vec", NULL
8716 };
8717
8718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8720 if (!SWIG_IsOK(res1)) {
8721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8722 }
8723 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8724 {
8725 arg2 = &temp2;
8726 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8727 }
8728 {
8729 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8730 if (PyErr_Occurred()) SWIG_fail;
8731 }
8732 resultobj = SWIG_From_double(static_cast< double >(result));
8733 return resultobj;
8734 fail:
8735 return NULL;
8736 }
8737
8738
8739 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8740 PyObject *resultobj = 0;
8741 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8742 wxPoint2D *arg2 = 0 ;
8743 double result;
8744 void *argp1 = 0 ;
8745 int res1 = 0 ;
8746 wxPoint2D temp2 ;
8747 PyObject * obj0 = 0 ;
8748 PyObject * obj1 = 0 ;
8749 char * kwnames[] = {
8750 (char *) "self",(char *) "vec", NULL
8751 };
8752
8753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8755 if (!SWIG_IsOK(res1)) {
8756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8757 }
8758 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8759 {
8760 arg2 = &temp2;
8761 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8762 }
8763 {
8764 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8765 if (PyErr_Occurred()) SWIG_fail;
8766 }
8767 resultobj = SWIG_From_double(static_cast< double >(result));
8768 return resultobj;
8769 fail:
8770 return NULL;
8771 }
8772
8773
8774 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8775 PyObject *resultobj = 0;
8776 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8777 wxPoint2D result;
8778 void *argp1 = 0 ;
8779 int res1 = 0 ;
8780 PyObject *swig_obj[1] ;
8781
8782 if (!args) SWIG_fail;
8783 swig_obj[0] = args;
8784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8785 if (!SWIG_IsOK(res1)) {
8786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8787 }
8788 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8789 {
8790 result = (arg1)->operator -();
8791 if (PyErr_Occurred()) SWIG_fail;
8792 }
8793 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8801 PyObject *resultobj = 0;
8802 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8803 wxPoint2D *arg2 = 0 ;
8804 wxPoint2D *result = 0 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 wxPoint2D temp2 ;
8808 PyObject * obj0 = 0 ;
8809 PyObject * obj1 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "pt", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8816 if (!SWIG_IsOK(res1)) {
8817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8818 }
8819 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8820 {
8821 arg2 = &temp2;
8822 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8823 }
8824 {
8825 {
8826 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8827 result = (wxPoint2D *) &_result_ref;
8828 }
8829 if (PyErr_Occurred()) SWIG_fail;
8830 }
8831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj = 0;
8840 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8841 wxPoint2D *arg2 = 0 ;
8842 wxPoint2D *result = 0 ;
8843 void *argp1 = 0 ;
8844 int res1 = 0 ;
8845 wxPoint2D temp2 ;
8846 PyObject * obj0 = 0 ;
8847 PyObject * obj1 = 0 ;
8848 char * kwnames[] = {
8849 (char *) "self",(char *) "pt", NULL
8850 };
8851
8852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8854 if (!SWIG_IsOK(res1)) {
8855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8856 }
8857 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8858 {
8859 arg2 = &temp2;
8860 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8861 }
8862 {
8863 {
8864 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8865 result = (wxPoint2D *) &_result_ref;
8866 }
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj = 0;
8878 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8879 wxPoint2D *arg2 = 0 ;
8880 wxPoint2D *result = 0 ;
8881 void *argp1 = 0 ;
8882 int res1 = 0 ;
8883 wxPoint2D temp2 ;
8884 PyObject * obj0 = 0 ;
8885 PyObject * obj1 = 0 ;
8886 char * kwnames[] = {
8887 (char *) "self",(char *) "pt", NULL
8888 };
8889
8890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8892 if (!SWIG_IsOK(res1)) {
8893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8894 }
8895 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8896 {
8897 arg2 = &temp2;
8898 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8899 }
8900 {
8901 {
8902 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8903 result = (wxPoint2D *) &_result_ref;
8904 }
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8908 return resultobj;
8909 fail:
8910 return NULL;
8911 }
8912
8913
8914 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj = 0;
8916 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8917 wxPoint2D *arg2 = 0 ;
8918 wxPoint2D *result = 0 ;
8919 void *argp1 = 0 ;
8920 int res1 = 0 ;
8921 wxPoint2D temp2 ;
8922 PyObject * obj0 = 0 ;
8923 PyObject * obj1 = 0 ;
8924 char * kwnames[] = {
8925 (char *) "self",(char *) "pt", NULL
8926 };
8927
8928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8930 if (!SWIG_IsOK(res1)) {
8931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8932 }
8933 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8934 {
8935 arg2 = &temp2;
8936 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8937 }
8938 {
8939 {
8940 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8941 result = (wxPoint2D *) &_result_ref;
8942 }
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8953 PyObject *resultobj = 0;
8954 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8955 PyObject *arg2 = (PyObject *) 0 ;
8956 bool result;
8957 void *argp1 = 0 ;
8958 int res1 = 0 ;
8959 PyObject * obj0 = 0 ;
8960 PyObject * obj1 = 0 ;
8961 char * kwnames[] = {
8962 (char *) "self",(char *) "other", NULL
8963 };
8964
8965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8967 if (!SWIG_IsOK(res1)) {
8968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8969 }
8970 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8971 arg2 = obj1;
8972 {
8973 result = (bool)wxPoint2D___eq__(arg1,arg2);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 {
8977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8978 }
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj = 0;
8987 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8988 PyObject *arg2 = (PyObject *) 0 ;
8989 bool result;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 PyObject * obj0 = 0 ;
8993 PyObject * obj1 = 0 ;
8994 char * kwnames[] = {
8995 (char *) "self",(char *) "other", NULL
8996 };
8997
8998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9000 if (!SWIG_IsOK(res1)) {
9001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9002 }
9003 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9004 arg2 = obj1;
9005 {
9006 result = (bool)wxPoint2D___ne__(arg1,arg2);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 {
9010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9011 }
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9019 PyObject *resultobj = 0;
9020 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9021 double arg2 ;
9022 void *argp1 = 0 ;
9023 int res1 = 0 ;
9024 double val2 ;
9025 int ecode2 = 0 ;
9026 PyObject *swig_obj[2] ;
9027
9028 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9030 if (!SWIG_IsOK(res1)) {
9031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9032 }
9033 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9034 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9035 if (!SWIG_IsOK(ecode2)) {
9036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9037 }
9038 arg2 = static_cast< double >(val2);
9039 if (arg1) (arg1)->m_x = arg2;
9040
9041 resultobj = SWIG_Py_Void();
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9051 double result;
9052 void *argp1 = 0 ;
9053 int res1 = 0 ;
9054 PyObject *swig_obj[1] ;
9055
9056 if (!args) SWIG_fail;
9057 swig_obj[0] = args;
9058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9061 }
9062 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9063 result = (double) ((arg1)->m_x);
9064 resultobj = SWIG_From_double(static_cast< double >(result));
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9072 PyObject *resultobj = 0;
9073 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9074 double arg2 ;
9075 void *argp1 = 0 ;
9076 int res1 = 0 ;
9077 double val2 ;
9078 int ecode2 = 0 ;
9079 PyObject *swig_obj[2] ;
9080
9081 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9083 if (!SWIG_IsOK(res1)) {
9084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9085 }
9086 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9087 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9088 if (!SWIG_IsOK(ecode2)) {
9089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9090 }
9091 arg2 = static_cast< double >(val2);
9092 if (arg1) (arg1)->m_y = arg2;
9093
9094 resultobj = SWIG_Py_Void();
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9102 PyObject *resultobj = 0;
9103 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9104 double result;
9105 void *argp1 = 0 ;
9106 int res1 = 0 ;
9107 PyObject *swig_obj[1] ;
9108
9109 if (!args) SWIG_fail;
9110 swig_obj[0] = args;
9111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9112 if (!SWIG_IsOK(res1)) {
9113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9114 }
9115 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9116 result = (double) ((arg1)->m_y);
9117 resultobj = SWIG_From_double(static_cast< double >(result));
9118 return resultobj;
9119 fail:
9120 return NULL;
9121 }
9122
9123
9124 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9125 PyObject *resultobj = 0;
9126 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9127 double arg2 = (double) 0 ;
9128 double arg3 = (double) 0 ;
9129 void *argp1 = 0 ;
9130 int res1 = 0 ;
9131 double val2 ;
9132 int ecode2 = 0 ;
9133 double val3 ;
9134 int ecode3 = 0 ;
9135 PyObject * obj0 = 0 ;
9136 PyObject * obj1 = 0 ;
9137 PyObject * obj2 = 0 ;
9138 char * kwnames[] = {
9139 (char *) "self",(char *) "x",(char *) "y", NULL
9140 };
9141
9142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9144 if (!SWIG_IsOK(res1)) {
9145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9146 }
9147 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9148 if (obj1) {
9149 ecode2 = SWIG_AsVal_double(obj1, &val2);
9150 if (!SWIG_IsOK(ecode2)) {
9151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9152 }
9153 arg2 = static_cast< double >(val2);
9154 }
9155 if (obj2) {
9156 ecode3 = SWIG_AsVal_double(obj2, &val3);
9157 if (!SWIG_IsOK(ecode3)) {
9158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9159 }
9160 arg3 = static_cast< double >(val3);
9161 }
9162 {
9163 wxPoint2D_Set(arg1,arg2,arg3);
9164 if (PyErr_Occurred()) SWIG_fail;
9165 }
9166 resultobj = SWIG_Py_Void();
9167 return resultobj;
9168 fail:
9169 return NULL;
9170 }
9171
9172
9173 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9174 PyObject *resultobj = 0;
9175 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9176 PyObject *result = 0 ;
9177 void *argp1 = 0 ;
9178 int res1 = 0 ;
9179 PyObject *swig_obj[1] ;
9180
9181 if (!args) SWIG_fail;
9182 swig_obj[0] = args;
9183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9184 if (!SWIG_IsOK(res1)) {
9185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9186 }
9187 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9188 {
9189 result = (PyObject *)wxPoint2D_Get(arg1);
9190 if (PyErr_Occurred()) SWIG_fail;
9191 }
9192 resultobj = result;
9193 return resultobj;
9194 fail:
9195 return NULL;
9196 }
9197
9198
9199 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9200 PyObject *obj;
9201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9202 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9203 return SWIG_Py_Void();
9204 }
9205
9206 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9207 return SWIG_Python_InitShadowInstance(args);
9208 }
9209
9210 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9211 PyObject *resultobj = 0;
9212 wxDouble arg1 = (wxDouble) 0.0 ;
9213 wxDouble arg2 = (wxDouble) 0.0 ;
9214 wxDouble arg3 = (wxDouble) 0.0 ;
9215 wxDouble arg4 = (wxDouble) 0.0 ;
9216 wxRect2D *result = 0 ;
9217 void *argp1 ;
9218 int res1 = 0 ;
9219 void *argp2 ;
9220 int res2 = 0 ;
9221 void *argp3 ;
9222 int res3 = 0 ;
9223 void *argp4 ;
9224 int res4 = 0 ;
9225 PyObject * obj0 = 0 ;
9226 PyObject * obj1 = 0 ;
9227 PyObject * obj2 = 0 ;
9228 PyObject * obj3 = 0 ;
9229 char * kwnames[] = {
9230 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9231 };
9232
9233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9234 if (obj0) {
9235 {
9236 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9239 }
9240 if (!argp1) {
9241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9242 } else {
9243 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9244 arg1 = *temp;
9245 if (SWIG_IsNewObj(res1)) delete temp;
9246 }
9247 }
9248 }
9249 if (obj1) {
9250 {
9251 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9252 if (!SWIG_IsOK(res2)) {
9253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9254 }
9255 if (!argp2) {
9256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9257 } else {
9258 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9259 arg2 = *temp;
9260 if (SWIG_IsNewObj(res2)) delete temp;
9261 }
9262 }
9263 }
9264 if (obj2) {
9265 {
9266 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9267 if (!SWIG_IsOK(res3)) {
9268 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9269 }
9270 if (!argp3) {
9271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9272 } else {
9273 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9274 arg3 = *temp;
9275 if (SWIG_IsNewObj(res3)) delete temp;
9276 }
9277 }
9278 }
9279 if (obj3) {
9280 {
9281 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9282 if (!SWIG_IsOK(res4)) {
9283 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9284 }
9285 if (!argp4) {
9286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9287 } else {
9288 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9289 arg4 = *temp;
9290 if (SWIG_IsNewObj(res4)) delete temp;
9291 }
9292 }
9293 }
9294 {
9295 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9306 PyObject *resultobj = 0;
9307 wxRect2D *arg1 = (wxRect2D *) 0 ;
9308 void *argp1 = 0 ;
9309 int res1 = 0 ;
9310 PyObject *swig_obj[1] ;
9311
9312 if (!args) SWIG_fail;
9313 swig_obj[0] = args;
9314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9315 if (!SWIG_IsOK(res1)) {
9316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9317 }
9318 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9319 {
9320 delete arg1;
9321
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9332 PyObject *resultobj = 0;
9333 wxRect2D *arg1 = (wxRect2D *) 0 ;
9334 wxPoint2D result;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 PyObject *swig_obj[1] ;
9338
9339 if (!args) SWIG_fail;
9340 swig_obj[0] = args;
9341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9342 if (!SWIG_IsOK(res1)) {
9343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9344 }
9345 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9346 {
9347 result = (arg1)->GetPosition();
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *resultobj = 0;
9359 wxRect2D *arg1 = (wxRect2D *) 0 ;
9360 wxSize result;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 PyObject *swig_obj[1] ;
9364
9365 if (!args) SWIG_fail;
9366 swig_obj[0] = args;
9367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9368 if (!SWIG_IsOK(res1)) {
9369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9370 }
9371 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9372 {
9373 result = (arg1)->GetSize();
9374 if (PyErr_Occurred()) SWIG_fail;
9375 }
9376 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9377 return resultobj;
9378 fail:
9379 return NULL;
9380 }
9381
9382
9383 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9384 PyObject *resultobj = 0;
9385 wxRect2D *arg1 = (wxRect2D *) 0 ;
9386 wxDouble result;
9387 void *argp1 = 0 ;
9388 int res1 = 0 ;
9389 PyObject *swig_obj[1] ;
9390
9391 if (!args) SWIG_fail;
9392 swig_obj[0] = args;
9393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9394 if (!SWIG_IsOK(res1)) {
9395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9396 }
9397 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9398 {
9399 result = ((wxRect2D const *)arg1)->GetLeft();
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9403 return resultobj;
9404 fail:
9405 return NULL;
9406 }
9407
9408
9409 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9410 PyObject *resultobj = 0;
9411 wxRect2D *arg1 = (wxRect2D *) 0 ;
9412 wxDouble arg2 ;
9413 void *argp1 = 0 ;
9414 int res1 = 0 ;
9415 void *argp2 ;
9416 int res2 = 0 ;
9417 PyObject * obj0 = 0 ;
9418 PyObject * obj1 = 0 ;
9419 char * kwnames[] = {
9420 (char *) "self",(char *) "n", NULL
9421 };
9422
9423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9425 if (!SWIG_IsOK(res1)) {
9426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9427 }
9428 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9429 {
9430 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9431 if (!SWIG_IsOK(res2)) {
9432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9433 }
9434 if (!argp2) {
9435 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9436 } else {
9437 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9438 arg2 = *temp;
9439 if (SWIG_IsNewObj(res2)) delete temp;
9440 }
9441 }
9442 {
9443 (arg1)->SetLeft(arg2);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 resultobj = SWIG_Py_Void();
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj = 0;
9455 wxRect2D *arg1 = (wxRect2D *) 0 ;
9456 wxDouble arg2 ;
9457 void *argp1 = 0 ;
9458 int res1 = 0 ;
9459 void *argp2 ;
9460 int res2 = 0 ;
9461 PyObject * obj0 = 0 ;
9462 PyObject * obj1 = 0 ;
9463 char * kwnames[] = {
9464 (char *) "self",(char *) "n", NULL
9465 };
9466
9467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9471 }
9472 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9473 {
9474 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9475 if (!SWIG_IsOK(res2)) {
9476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9477 }
9478 if (!argp2) {
9479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9480 } else {
9481 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9482 arg2 = *temp;
9483 if (SWIG_IsNewObj(res2)) delete temp;
9484 }
9485 }
9486 {
9487 (arg1)->MoveLeftTo(arg2);
9488 if (PyErr_Occurred()) SWIG_fail;
9489 }
9490 resultobj = SWIG_Py_Void();
9491 return resultobj;
9492 fail:
9493 return NULL;
9494 }
9495
9496
9497 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9498 PyObject *resultobj = 0;
9499 wxRect2D *arg1 = (wxRect2D *) 0 ;
9500 wxDouble result;
9501 void *argp1 = 0 ;
9502 int res1 = 0 ;
9503 PyObject *swig_obj[1] ;
9504
9505 if (!args) SWIG_fail;
9506 swig_obj[0] = args;
9507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9508 if (!SWIG_IsOK(res1)) {
9509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9510 }
9511 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9512 {
9513 result = ((wxRect2D const *)arg1)->GetTop();
9514 if (PyErr_Occurred()) SWIG_fail;
9515 }
9516 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9517 return resultobj;
9518 fail:
9519 return NULL;
9520 }
9521
9522
9523 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9524 PyObject *resultobj = 0;
9525 wxRect2D *arg1 = (wxRect2D *) 0 ;
9526 wxDouble arg2 ;
9527 void *argp1 = 0 ;
9528 int res1 = 0 ;
9529 void *argp2 ;
9530 int res2 = 0 ;
9531 PyObject * obj0 = 0 ;
9532 PyObject * obj1 = 0 ;
9533 char * kwnames[] = {
9534 (char *) "self",(char *) "n", NULL
9535 };
9536
9537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9539 if (!SWIG_IsOK(res1)) {
9540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9541 }
9542 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9543 {
9544 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9545 if (!SWIG_IsOK(res2)) {
9546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9547 }
9548 if (!argp2) {
9549 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9550 } else {
9551 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9552 arg2 = *temp;
9553 if (SWIG_IsNewObj(res2)) delete temp;
9554 }
9555 }
9556 {
9557 (arg1)->SetTop(arg2);
9558 if (PyErr_Occurred()) SWIG_fail;
9559 }
9560 resultobj = SWIG_Py_Void();
9561 return resultobj;
9562 fail:
9563 return NULL;
9564 }
9565
9566
9567 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9568 PyObject *resultobj = 0;
9569 wxRect2D *arg1 = (wxRect2D *) 0 ;
9570 wxDouble arg2 ;
9571 void *argp1 = 0 ;
9572 int res1 = 0 ;
9573 void *argp2 ;
9574 int res2 = 0 ;
9575 PyObject * obj0 = 0 ;
9576 PyObject * obj1 = 0 ;
9577 char * kwnames[] = {
9578 (char *) "self",(char *) "n", NULL
9579 };
9580
9581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9583 if (!SWIG_IsOK(res1)) {
9584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9585 }
9586 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9587 {
9588 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9589 if (!SWIG_IsOK(res2)) {
9590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9591 }
9592 if (!argp2) {
9593 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9594 } else {
9595 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9596 arg2 = *temp;
9597 if (SWIG_IsNewObj(res2)) delete temp;
9598 }
9599 }
9600 {
9601 (arg1)->MoveTopTo(arg2);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_Py_Void();
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9612 PyObject *resultobj = 0;
9613 wxRect2D *arg1 = (wxRect2D *) 0 ;
9614 wxDouble result;
9615 void *argp1 = 0 ;
9616 int res1 = 0 ;
9617 PyObject *swig_obj[1] ;
9618
9619 if (!args) SWIG_fail;
9620 swig_obj[0] = args;
9621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9622 if (!SWIG_IsOK(res1)) {
9623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9624 }
9625 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9626 {
9627 result = ((wxRect2D const *)arg1)->GetBottom();
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9631 return resultobj;
9632 fail:
9633 return NULL;
9634 }
9635
9636
9637 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9638 PyObject *resultobj = 0;
9639 wxRect2D *arg1 = (wxRect2D *) 0 ;
9640 wxDouble arg2 ;
9641 void *argp1 = 0 ;
9642 int res1 = 0 ;
9643 void *argp2 ;
9644 int res2 = 0 ;
9645 PyObject * obj0 = 0 ;
9646 PyObject * obj1 = 0 ;
9647 char * kwnames[] = {
9648 (char *) "self",(char *) "n", NULL
9649 };
9650
9651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9653 if (!SWIG_IsOK(res1)) {
9654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9655 }
9656 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9657 {
9658 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9659 if (!SWIG_IsOK(res2)) {
9660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9661 }
9662 if (!argp2) {
9663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9664 } else {
9665 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9666 arg2 = *temp;
9667 if (SWIG_IsNewObj(res2)) delete temp;
9668 }
9669 }
9670 {
9671 (arg1)->SetBottom(arg2);
9672 if (PyErr_Occurred()) SWIG_fail;
9673 }
9674 resultobj = SWIG_Py_Void();
9675 return resultobj;
9676 fail:
9677 return NULL;
9678 }
9679
9680
9681 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9682 PyObject *resultobj = 0;
9683 wxRect2D *arg1 = (wxRect2D *) 0 ;
9684 wxDouble arg2 ;
9685 void *argp1 = 0 ;
9686 int res1 = 0 ;
9687 void *argp2 ;
9688 int res2 = 0 ;
9689 PyObject * obj0 = 0 ;
9690 PyObject * obj1 = 0 ;
9691 char * kwnames[] = {
9692 (char *) "self",(char *) "n", NULL
9693 };
9694
9695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9697 if (!SWIG_IsOK(res1)) {
9698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9699 }
9700 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9701 {
9702 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9703 if (!SWIG_IsOK(res2)) {
9704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9705 }
9706 if (!argp2) {
9707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9708 } else {
9709 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9710 arg2 = *temp;
9711 if (SWIG_IsNewObj(res2)) delete temp;
9712 }
9713 }
9714 {
9715 (arg1)->MoveBottomTo(arg2);
9716 if (PyErr_Occurred()) SWIG_fail;
9717 }
9718 resultobj = SWIG_Py_Void();
9719 return resultobj;
9720 fail:
9721 return NULL;
9722 }
9723
9724
9725 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9726 PyObject *resultobj = 0;
9727 wxRect2D *arg1 = (wxRect2D *) 0 ;
9728 wxDouble result;
9729 void *argp1 = 0 ;
9730 int res1 = 0 ;
9731 PyObject *swig_obj[1] ;
9732
9733 if (!args) SWIG_fail;
9734 swig_obj[0] = args;
9735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9736 if (!SWIG_IsOK(res1)) {
9737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9738 }
9739 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9740 {
9741 result = ((wxRect2D const *)arg1)->GetRight();
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9752 PyObject *resultobj = 0;
9753 wxRect2D *arg1 = (wxRect2D *) 0 ;
9754 wxDouble arg2 ;
9755 void *argp1 = 0 ;
9756 int res1 = 0 ;
9757 void *argp2 ;
9758 int res2 = 0 ;
9759 PyObject * obj0 = 0 ;
9760 PyObject * obj1 = 0 ;
9761 char * kwnames[] = {
9762 (char *) "self",(char *) "n", NULL
9763 };
9764
9765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9767 if (!SWIG_IsOK(res1)) {
9768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9769 }
9770 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9771 {
9772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9773 if (!SWIG_IsOK(res2)) {
9774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9775 }
9776 if (!argp2) {
9777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9778 } else {
9779 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9780 arg2 = *temp;
9781 if (SWIG_IsNewObj(res2)) delete temp;
9782 }
9783 }
9784 {
9785 (arg1)->SetRight(arg2);
9786 if (PyErr_Occurred()) SWIG_fail;
9787 }
9788 resultobj = SWIG_Py_Void();
9789 return resultobj;
9790 fail:
9791 return NULL;
9792 }
9793
9794
9795 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9796 PyObject *resultobj = 0;
9797 wxRect2D *arg1 = (wxRect2D *) 0 ;
9798 wxDouble arg2 ;
9799 void *argp1 = 0 ;
9800 int res1 = 0 ;
9801 void *argp2 ;
9802 int res2 = 0 ;
9803 PyObject * obj0 = 0 ;
9804 PyObject * obj1 = 0 ;
9805 char * kwnames[] = {
9806 (char *) "self",(char *) "n", NULL
9807 };
9808
9809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9811 if (!SWIG_IsOK(res1)) {
9812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9813 }
9814 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9815 {
9816 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9817 if (!SWIG_IsOK(res2)) {
9818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9819 }
9820 if (!argp2) {
9821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9822 } else {
9823 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9824 arg2 = *temp;
9825 if (SWIG_IsNewObj(res2)) delete temp;
9826 }
9827 }
9828 {
9829 (arg1)->MoveRightTo(arg2);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 resultobj = SWIG_Py_Void();
9833 return resultobj;
9834 fail:
9835 return NULL;
9836 }
9837
9838
9839 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9840 PyObject *resultobj = 0;
9841 wxRect2D *arg1 = (wxRect2D *) 0 ;
9842 wxPoint2D result;
9843 void *argp1 = 0 ;
9844 int res1 = 0 ;
9845 PyObject *swig_obj[1] ;
9846
9847 if (!args) SWIG_fail;
9848 swig_obj[0] = args;
9849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9850 if (!SWIG_IsOK(res1)) {
9851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9852 }
9853 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9854 {
9855 result = ((wxRect2D const *)arg1)->GetLeftTop();
9856 if (PyErr_Occurred()) SWIG_fail;
9857 }
9858 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9866 PyObject *resultobj = 0;
9867 wxRect2D *arg1 = (wxRect2D *) 0 ;
9868 wxPoint2D *arg2 = 0 ;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 wxPoint2D temp2 ;
9872 PyObject * obj0 = 0 ;
9873 PyObject * obj1 = 0 ;
9874 char * kwnames[] = {
9875 (char *) "self",(char *) "pt", NULL
9876 };
9877
9878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9880 if (!SWIG_IsOK(res1)) {
9881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9882 }
9883 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9884 {
9885 arg2 = &temp2;
9886 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9887 }
9888 {
9889 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9890 if (PyErr_Occurred()) SWIG_fail;
9891 }
9892 resultobj = SWIG_Py_Void();
9893 return resultobj;
9894 fail:
9895 return NULL;
9896 }
9897
9898
9899 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj = 0;
9901 wxRect2D *arg1 = (wxRect2D *) 0 ;
9902 wxPoint2D *arg2 = 0 ;
9903 void *argp1 = 0 ;
9904 int res1 = 0 ;
9905 wxPoint2D temp2 ;
9906 PyObject * obj0 = 0 ;
9907 PyObject * obj1 = 0 ;
9908 char * kwnames[] = {
9909 (char *) "self",(char *) "pt", NULL
9910 };
9911
9912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9914 if (!SWIG_IsOK(res1)) {
9915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9916 }
9917 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9918 {
9919 arg2 = &temp2;
9920 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9921 }
9922 {
9923 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 resultobj = SWIG_Py_Void();
9927 return resultobj;
9928 fail:
9929 return NULL;
9930 }
9931
9932
9933 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9934 PyObject *resultobj = 0;
9935 wxRect2D *arg1 = (wxRect2D *) 0 ;
9936 wxPoint2D result;
9937 void *argp1 = 0 ;
9938 int res1 = 0 ;
9939 PyObject *swig_obj[1] ;
9940
9941 if (!args) SWIG_fail;
9942 swig_obj[0] = args;
9943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9944 if (!SWIG_IsOK(res1)) {
9945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9946 }
9947 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9948 {
9949 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj = 0;
9961 wxRect2D *arg1 = (wxRect2D *) 0 ;
9962 wxPoint2D *arg2 = 0 ;
9963 void *argp1 = 0 ;
9964 int res1 = 0 ;
9965 wxPoint2D temp2 ;
9966 PyObject * obj0 = 0 ;
9967 PyObject * obj1 = 0 ;
9968 char * kwnames[] = {
9969 (char *) "self",(char *) "pt", NULL
9970 };
9971
9972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9974 if (!SWIG_IsOK(res1)) {
9975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9976 }
9977 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9978 {
9979 arg2 = &temp2;
9980 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9981 }
9982 {
9983 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_Py_Void();
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9994 PyObject *resultobj = 0;
9995 wxRect2D *arg1 = (wxRect2D *) 0 ;
9996 wxPoint2D *arg2 = 0 ;
9997 void *argp1 = 0 ;
9998 int res1 = 0 ;
9999 wxPoint2D temp2 ;
10000 PyObject * obj0 = 0 ;
10001 PyObject * obj1 = 0 ;
10002 char * kwnames[] = {
10003 (char *) "self",(char *) "pt", NULL
10004 };
10005
10006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10008 if (!SWIG_IsOK(res1)) {
10009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10010 }
10011 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10012 {
10013 arg2 = &temp2;
10014 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10015 }
10016 {
10017 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 resultobj = SWIG_Py_Void();
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *resultobj = 0;
10029 wxRect2D *arg1 = (wxRect2D *) 0 ;
10030 wxPoint2D result;
10031 void *argp1 = 0 ;
10032 int res1 = 0 ;
10033 PyObject *swig_obj[1] ;
10034
10035 if (!args) SWIG_fail;
10036 swig_obj[0] = args;
10037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10038 if (!SWIG_IsOK(res1)) {
10039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10040 }
10041 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10042 {
10043 result = ((wxRect2D const *)arg1)->GetRightTop();
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10047 return resultobj;
10048 fail:
10049 return NULL;
10050 }
10051
10052
10053 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10054 PyObject *resultobj = 0;
10055 wxRect2D *arg1 = (wxRect2D *) 0 ;
10056 wxPoint2D *arg2 = 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 wxPoint2D temp2 ;
10060 PyObject * obj0 = 0 ;
10061 PyObject * obj1 = 0 ;
10062 char * kwnames[] = {
10063 (char *) "self",(char *) "pt", NULL
10064 };
10065
10066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10068 if (!SWIG_IsOK(res1)) {
10069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10070 }
10071 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10072 {
10073 arg2 = &temp2;
10074 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10075 }
10076 {
10077 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 resultobj = SWIG_Py_Void();
10081 return resultobj;
10082 fail:
10083 return NULL;
10084 }
10085
10086
10087 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj = 0;
10089 wxRect2D *arg1 = (wxRect2D *) 0 ;
10090 wxPoint2D *arg2 = 0 ;
10091 void *argp1 = 0 ;
10092 int res1 = 0 ;
10093 wxPoint2D temp2 ;
10094 PyObject * obj0 = 0 ;
10095 PyObject * obj1 = 0 ;
10096 char * kwnames[] = {
10097 (char *) "self",(char *) "pt", NULL
10098 };
10099
10100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10102 if (!SWIG_IsOK(res1)) {
10103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10104 }
10105 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10106 {
10107 arg2 = &temp2;
10108 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10109 }
10110 {
10111 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10112 if (PyErr_Occurred()) SWIG_fail;
10113 }
10114 resultobj = SWIG_Py_Void();
10115 return resultobj;
10116 fail:
10117 return NULL;
10118 }
10119
10120
10121 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10122 PyObject *resultobj = 0;
10123 wxRect2D *arg1 = (wxRect2D *) 0 ;
10124 wxPoint2D result;
10125 void *argp1 = 0 ;
10126 int res1 = 0 ;
10127 PyObject *swig_obj[1] ;
10128
10129 if (!args) SWIG_fail;
10130 swig_obj[0] = args;
10131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10132 if (!SWIG_IsOK(res1)) {
10133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10134 }
10135 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10136 {
10137 result = ((wxRect2D const *)arg1)->GetRightBottom();
10138 if (PyErr_Occurred()) SWIG_fail;
10139 }
10140 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10141 return resultobj;
10142 fail:
10143 return NULL;
10144 }
10145
10146
10147 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10148 PyObject *resultobj = 0;
10149 wxRect2D *arg1 = (wxRect2D *) 0 ;
10150 wxPoint2D *arg2 = 0 ;
10151 void *argp1 = 0 ;
10152 int res1 = 0 ;
10153 wxPoint2D temp2 ;
10154 PyObject * obj0 = 0 ;
10155 PyObject * obj1 = 0 ;
10156 char * kwnames[] = {
10157 (char *) "self",(char *) "pt", NULL
10158 };
10159
10160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10162 if (!SWIG_IsOK(res1)) {
10163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10164 }
10165 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10166 {
10167 arg2 = &temp2;
10168 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10169 }
10170 {
10171 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10172 if (PyErr_Occurred()) SWIG_fail;
10173 }
10174 resultobj = SWIG_Py_Void();
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10182 PyObject *resultobj = 0;
10183 wxRect2D *arg1 = (wxRect2D *) 0 ;
10184 wxPoint2D *arg2 = 0 ;
10185 void *argp1 = 0 ;
10186 int res1 = 0 ;
10187 wxPoint2D temp2 ;
10188 PyObject * obj0 = 0 ;
10189 PyObject * obj1 = 0 ;
10190 char * kwnames[] = {
10191 (char *) "self",(char *) "pt", NULL
10192 };
10193
10194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10196 if (!SWIG_IsOK(res1)) {
10197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10198 }
10199 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10200 {
10201 arg2 = &temp2;
10202 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10203 }
10204 {
10205 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 resultobj = SWIG_Py_Void();
10209 return resultobj;
10210 fail:
10211 return NULL;
10212 }
10213
10214
10215 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10216 PyObject *resultobj = 0;
10217 wxRect2D *arg1 = (wxRect2D *) 0 ;
10218 wxPoint2D result;
10219 void *argp1 = 0 ;
10220 int res1 = 0 ;
10221 PyObject *swig_obj[1] ;
10222
10223 if (!args) SWIG_fail;
10224 swig_obj[0] = args;
10225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10226 if (!SWIG_IsOK(res1)) {
10227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10228 }
10229 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10230 {
10231 result = ((wxRect2D const *)arg1)->GetCentre();
10232 if (PyErr_Occurred()) SWIG_fail;
10233 }
10234 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10235 return resultobj;
10236 fail:
10237 return NULL;
10238 }
10239
10240
10241 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10242 PyObject *resultobj = 0;
10243 wxRect2D *arg1 = (wxRect2D *) 0 ;
10244 wxPoint2D *arg2 = 0 ;
10245 void *argp1 = 0 ;
10246 int res1 = 0 ;
10247 wxPoint2D temp2 ;
10248 PyObject * obj0 = 0 ;
10249 PyObject * obj1 = 0 ;
10250 char * kwnames[] = {
10251 (char *) "self",(char *) "pt", NULL
10252 };
10253
10254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10256 if (!SWIG_IsOK(res1)) {
10257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10258 }
10259 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10260 {
10261 arg2 = &temp2;
10262 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10263 }
10264 {
10265 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10266 if (PyErr_Occurred()) SWIG_fail;
10267 }
10268 resultobj = SWIG_Py_Void();
10269 return resultobj;
10270 fail:
10271 return NULL;
10272 }
10273
10274
10275 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10276 PyObject *resultobj = 0;
10277 wxRect2D *arg1 = (wxRect2D *) 0 ;
10278 wxPoint2D *arg2 = 0 ;
10279 void *argp1 = 0 ;
10280 int res1 = 0 ;
10281 wxPoint2D temp2 ;
10282 PyObject * obj0 = 0 ;
10283 PyObject * obj1 = 0 ;
10284 char * kwnames[] = {
10285 (char *) "self",(char *) "pt", NULL
10286 };
10287
10288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10290 if (!SWIG_IsOK(res1)) {
10291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10292 }
10293 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10294 {
10295 arg2 = &temp2;
10296 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10297 }
10298 {
10299 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10300 if (PyErr_Occurred()) SWIG_fail;
10301 }
10302 resultobj = SWIG_Py_Void();
10303 return resultobj;
10304 fail:
10305 return NULL;
10306 }
10307
10308
10309 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10310 PyObject *resultobj = 0;
10311 wxRect2D *arg1 = (wxRect2D *) 0 ;
10312 wxPoint2D *arg2 = 0 ;
10313 wxOutCode result;
10314 void *argp1 = 0 ;
10315 int res1 = 0 ;
10316 wxPoint2D temp2 ;
10317 PyObject * obj0 = 0 ;
10318 PyObject * obj1 = 0 ;
10319 char * kwnames[] = {
10320 (char *) "self",(char *) "pt", NULL
10321 };
10322
10323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10325 if (!SWIG_IsOK(res1)) {
10326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10327 }
10328 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10329 {
10330 arg2 = &temp2;
10331 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10332 }
10333 {
10334 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10335 if (PyErr_Occurred()) SWIG_fail;
10336 }
10337 resultobj = SWIG_From_int(static_cast< int >(result));
10338 return resultobj;
10339 fail:
10340 return NULL;
10341 }
10342
10343
10344 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10345 PyObject *resultobj = 0;
10346 wxRect2D *arg1 = (wxRect2D *) 0 ;
10347 wxPoint2D *arg2 = 0 ;
10348 bool result;
10349 void *argp1 = 0 ;
10350 int res1 = 0 ;
10351 wxPoint2D temp2 ;
10352 PyObject * obj0 = 0 ;
10353 PyObject * obj1 = 0 ;
10354 char * kwnames[] = {
10355 (char *) "self",(char *) "pt", NULL
10356 };
10357
10358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10360 if (!SWIG_IsOK(res1)) {
10361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10362 }
10363 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10364 {
10365 arg2 = &temp2;
10366 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10367 }
10368 {
10369 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10370 if (PyErr_Occurred()) SWIG_fail;
10371 }
10372 {
10373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10374 }
10375 return resultobj;
10376 fail:
10377 return NULL;
10378 }
10379
10380
10381 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10382 PyObject *resultobj = 0;
10383 wxRect2D *arg1 = (wxRect2D *) 0 ;
10384 wxRect2D *arg2 = 0 ;
10385 bool result;
10386 void *argp1 = 0 ;
10387 int res1 = 0 ;
10388 wxRect2D temp2 ;
10389 PyObject * obj0 = 0 ;
10390 PyObject * obj1 = 0 ;
10391 char * kwnames[] = {
10392 (char *) "self",(char *) "rect", NULL
10393 };
10394
10395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10397 if (!SWIG_IsOK(res1)) {
10398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10399 }
10400 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10401 {
10402 arg2 = &temp2;
10403 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10404 }
10405 {
10406 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10407 if (PyErr_Occurred()) SWIG_fail;
10408 }
10409 {
10410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10411 }
10412 return resultobj;
10413 fail:
10414 return NULL;
10415 }
10416
10417
10418 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10419 PyObject *resultobj = 0;
10420 wxRect2D *arg1 = (wxRect2D *) 0 ;
10421 bool result;
10422 void *argp1 = 0 ;
10423 int res1 = 0 ;
10424 PyObject *swig_obj[1] ;
10425
10426 if (!args) SWIG_fail;
10427 swig_obj[0] = args;
10428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10429 if (!SWIG_IsOK(res1)) {
10430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10431 }
10432 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10433 {
10434 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 {
10438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10439 }
10440 return resultobj;
10441 fail:
10442 return NULL;
10443 }
10444
10445
10446 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10447 PyObject *resultobj = 0;
10448 wxRect2D *arg1 = (wxRect2D *) 0 ;
10449 wxRect2D *arg2 = 0 ;
10450 bool result;
10451 void *argp1 = 0 ;
10452 int res1 = 0 ;
10453 wxRect2D temp2 ;
10454 PyObject * obj0 = 0 ;
10455 PyObject * obj1 = 0 ;
10456 char * kwnames[] = {
10457 (char *) "self",(char *) "rect", NULL
10458 };
10459
10460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10462 if (!SWIG_IsOK(res1)) {
10463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10464 }
10465 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10466 {
10467 arg2 = &temp2;
10468 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10469 }
10470 {
10471 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10472 if (PyErr_Occurred()) SWIG_fail;
10473 }
10474 {
10475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10476 }
10477 return resultobj;
10478 fail:
10479 return NULL;
10480 }
10481
10482
10483 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10484 PyObject *resultobj = 0;
10485 wxRect2D *arg1 = (wxRect2D *) 0 ;
10486 wxDouble arg2 ;
10487 wxDouble arg3 ;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 void *argp2 ;
10491 int res2 = 0 ;
10492 void *argp3 ;
10493 int res3 = 0 ;
10494
10495 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10497 if (!SWIG_IsOK(res1)) {
10498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10499 }
10500 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10501 {
10502 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10503 if (!SWIG_IsOK(res2)) {
10504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10505 }
10506 if (!argp2) {
10507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10508 } else {
10509 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10510 arg2 = *temp;
10511 if (SWIG_IsNewObj(res2)) delete temp;
10512 }
10513 }
10514 {
10515 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10516 if (!SWIG_IsOK(res3)) {
10517 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10518 }
10519 if (!argp3) {
10520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10521 } else {
10522 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10523 arg3 = *temp;
10524 if (SWIG_IsNewObj(res3)) delete temp;
10525 }
10526 }
10527 {
10528 (arg1)->Inset(arg2,arg3);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 resultobj = SWIG_Py_Void();
10532 return resultobj;
10533 fail:
10534 return NULL;
10535 }
10536
10537
10538 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10539 PyObject *resultobj = 0;
10540 wxRect2D *arg1 = (wxRect2D *) 0 ;
10541 wxDouble arg2 ;
10542 wxDouble arg3 ;
10543 wxDouble arg4 ;
10544 wxDouble arg5 ;
10545 void *argp1 = 0 ;
10546 int res1 = 0 ;
10547 void *argp2 ;
10548 int res2 = 0 ;
10549 void *argp3 ;
10550 int res3 = 0 ;
10551 void *argp4 ;
10552 int res4 = 0 ;
10553 void *argp5 ;
10554 int res5 = 0 ;
10555
10556 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10558 if (!SWIG_IsOK(res1)) {
10559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10560 }
10561 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10562 {
10563 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10564 if (!SWIG_IsOK(res2)) {
10565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10566 }
10567 if (!argp2) {
10568 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10569 } else {
10570 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10571 arg2 = *temp;
10572 if (SWIG_IsNewObj(res2)) delete temp;
10573 }
10574 }
10575 {
10576 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10577 if (!SWIG_IsOK(res3)) {
10578 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10579 }
10580 if (!argp3) {
10581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10582 } else {
10583 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10584 arg3 = *temp;
10585 if (SWIG_IsNewObj(res3)) delete temp;
10586 }
10587 }
10588 {
10589 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10590 if (!SWIG_IsOK(res4)) {
10591 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10592 }
10593 if (!argp4) {
10594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10595 } else {
10596 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10597 arg4 = *temp;
10598 if (SWIG_IsNewObj(res4)) delete temp;
10599 }
10600 }
10601 {
10602 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10603 if (!SWIG_IsOK(res5)) {
10604 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10605 }
10606 if (!argp5) {
10607 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10608 } else {
10609 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10610 arg5 = *temp;
10611 if (SWIG_IsNewObj(res5)) delete temp;
10612 }
10613 }
10614 {
10615 (arg1)->Inset(arg2,arg3,arg4,arg5);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 resultobj = SWIG_Py_Void();
10619 return resultobj;
10620 fail:
10621 return NULL;
10622 }
10623
10624
10625 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10626 int argc;
10627 PyObject *argv[6];
10628
10629 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10630 --argc;
10631 if (argc == 3) {
10632 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10633 }
10634 if (argc == 5) {
10635 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10636 }
10637
10638 fail:
10639 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10640 return NULL;
10641 }
10642
10643
10644 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10645 PyObject *resultobj = 0;
10646 wxRect2D *arg1 = (wxRect2D *) 0 ;
10647 wxPoint2D *arg2 = 0 ;
10648 void *argp1 = 0 ;
10649 int res1 = 0 ;
10650 wxPoint2D temp2 ;
10651 PyObject * obj0 = 0 ;
10652 PyObject * obj1 = 0 ;
10653 char * kwnames[] = {
10654 (char *) "self",(char *) "pt", NULL
10655 };
10656
10657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10659 if (!SWIG_IsOK(res1)) {
10660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10661 }
10662 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10663 {
10664 arg2 = &temp2;
10665 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10666 }
10667 {
10668 (arg1)->Offset((wxPoint2D const &)*arg2);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 resultobj = SWIG_Py_Void();
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10679 PyObject *resultobj = 0;
10680 wxRect2D *arg1 = (wxRect2D *) 0 ;
10681 wxRect2D *arg2 = 0 ;
10682 void *argp1 = 0 ;
10683 int res1 = 0 ;
10684 wxRect2D temp2 ;
10685 PyObject * obj0 = 0 ;
10686 PyObject * obj1 = 0 ;
10687 char * kwnames[] = {
10688 (char *) "self",(char *) "rect", NULL
10689 };
10690
10691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10693 if (!SWIG_IsOK(res1)) {
10694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10695 }
10696 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10697 {
10698 arg2 = &temp2;
10699 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10700 }
10701 {
10702 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10703 if (PyErr_Occurred()) SWIG_fail;
10704 }
10705 resultobj = SWIG_Py_Void();
10706 return resultobj;
10707 fail:
10708 return NULL;
10709 }
10710
10711
10712 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10713 PyObject *resultobj = 0;
10714 wxRect2D *arg1 = (wxRect2D *) 0 ;
10715 int arg2 ;
10716 int arg3 ;
10717 wxPoint2D result;
10718 void *argp1 = 0 ;
10719 int res1 = 0 ;
10720 int val2 ;
10721 int ecode2 = 0 ;
10722 int val3 ;
10723 int ecode3 = 0 ;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 PyObject * obj2 = 0 ;
10727 char * kwnames[] = {
10728 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10729 };
10730
10731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10733 if (!SWIG_IsOK(res1)) {
10734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10735 }
10736 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10737 ecode2 = SWIG_AsVal_int(obj1, &val2);
10738 if (!SWIG_IsOK(ecode2)) {
10739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10740 }
10741 arg2 = static_cast< int >(val2);
10742 ecode3 = SWIG_AsVal_int(obj2, &val3);
10743 if (!SWIG_IsOK(ecode3)) {
10744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10745 }
10746 arg3 = static_cast< int >(val3);
10747 {
10748 result = (arg1)->Interpolate(arg2,arg3);
10749 if (PyErr_Occurred()) SWIG_fail;
10750 }
10751 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10752 return resultobj;
10753 fail:
10754 return NULL;
10755 }
10756
10757
10758 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10759 PyObject *resultobj = 0;
10760 wxRect2D *arg1 = (wxRect2D *) 0 ;
10761 wxRect2D *arg2 = 0 ;
10762 void *argp1 = 0 ;
10763 int res1 = 0 ;
10764 wxRect2D temp2 ;
10765 PyObject * obj0 = 0 ;
10766 PyObject * obj1 = 0 ;
10767 char * kwnames[] = {
10768 (char *) "self",(char *) "otherRect", NULL
10769 };
10770
10771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10773 if (!SWIG_IsOK(res1)) {
10774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10775 }
10776 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10777 {
10778 arg2 = &temp2;
10779 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10780 }
10781 {
10782 (arg1)->Intersect((wxRect2D const &)*arg2);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 resultobj = SWIG_Py_Void();
10786 return resultobj;
10787 fail:
10788 return NULL;
10789 }
10790
10791
10792 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj = 0;
10794 wxRect2D *arg1 = (wxRect2D *) 0 ;
10795 wxRect2D *arg2 = 0 ;
10796 wxRect2D result;
10797 void *argp1 = 0 ;
10798 int res1 = 0 ;
10799 wxRect2D temp2 ;
10800 PyObject * obj0 = 0 ;
10801 PyObject * obj1 = 0 ;
10802 char * kwnames[] = {
10803 (char *) "self",(char *) "otherRect", NULL
10804 };
10805
10806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10808 if (!SWIG_IsOK(res1)) {
10809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10810 }
10811 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10812 {
10813 arg2 = &temp2;
10814 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10815 }
10816 {
10817 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10818 if (PyErr_Occurred()) SWIG_fail;
10819 }
10820 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = 0;
10829 wxRect2D *arg1 = (wxRect2D *) 0 ;
10830 wxRect2D *arg2 = 0 ;
10831 bool result;
10832 void *argp1 = 0 ;
10833 int res1 = 0 ;
10834 wxRect2D temp2 ;
10835 PyObject * obj0 = 0 ;
10836 PyObject * obj1 = 0 ;
10837 char * kwnames[] = {
10838 (char *) "self",(char *) "rect", NULL
10839 };
10840
10841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10843 if (!SWIG_IsOK(res1)) {
10844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10845 }
10846 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10847 {
10848 arg2 = &temp2;
10849 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10850 }
10851 {
10852 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 {
10856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10857 }
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj = 0;
10866 wxRect2D *arg1 = (wxRect2D *) 0 ;
10867 wxRect2D *arg2 = 0 ;
10868 void *argp1 = 0 ;
10869 int res1 = 0 ;
10870 wxRect2D temp2 ;
10871 PyObject * obj0 = 0 ;
10872 PyObject * obj1 = 0 ;
10873 char * kwnames[] = {
10874 (char *) "self",(char *) "otherRect", NULL
10875 };
10876
10877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10879 if (!SWIG_IsOK(res1)) {
10880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10881 }
10882 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10883 {
10884 arg2 = &temp2;
10885 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10886 }
10887 {
10888 (arg1)->Union((wxRect2D const &)*arg2);
10889 if (PyErr_Occurred()) SWIG_fail;
10890 }
10891 resultobj = SWIG_Py_Void();
10892 return resultobj;
10893 fail:
10894 return NULL;
10895 }
10896
10897
10898 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10899 PyObject *resultobj = 0;
10900 wxRect2D *arg1 = (wxRect2D *) 0 ;
10901 wxRect2D *arg2 = 0 ;
10902 wxRect2D result;
10903 void *argp1 = 0 ;
10904 int res1 = 0 ;
10905 wxRect2D temp2 ;
10906 PyObject * obj0 = 0 ;
10907 PyObject * obj1 = 0 ;
10908 char * kwnames[] = {
10909 (char *) "self",(char *) "otherRect", NULL
10910 };
10911
10912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10914 if (!SWIG_IsOK(res1)) {
10915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10916 }
10917 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10918 {
10919 arg2 = &temp2;
10920 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10921 }
10922 {
10923 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10934 PyObject *resultobj = 0;
10935 wxRect2D *arg1 = (wxRect2D *) 0 ;
10936 wxDouble arg2 ;
10937 void *argp1 = 0 ;
10938 int res1 = 0 ;
10939 void *argp2 ;
10940 int res2 = 0 ;
10941
10942 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10944 if (!SWIG_IsOK(res1)) {
10945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10946 }
10947 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10948 {
10949 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10950 if (!SWIG_IsOK(res2)) {
10951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10952 }
10953 if (!argp2) {
10954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10955 } else {
10956 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10957 arg2 = *temp;
10958 if (SWIG_IsNewObj(res2)) delete temp;
10959 }
10960 }
10961 {
10962 (arg1)->Scale(arg2);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 resultobj = SWIG_Py_Void();
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10973 PyObject *resultobj = 0;
10974 wxRect2D *arg1 = (wxRect2D *) 0 ;
10975 int arg2 ;
10976 int arg3 ;
10977 void *argp1 = 0 ;
10978 int res1 = 0 ;
10979 int val2 ;
10980 int ecode2 = 0 ;
10981 int val3 ;
10982 int ecode3 = 0 ;
10983
10984 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10986 if (!SWIG_IsOK(res1)) {
10987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10988 }
10989 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10990 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10991 if (!SWIG_IsOK(ecode2)) {
10992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10993 }
10994 arg2 = static_cast< int >(val2);
10995 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10996 if (!SWIG_IsOK(ecode3)) {
10997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10998 }
10999 arg3 = static_cast< int >(val3);
11000 {
11001 (arg1)->Scale(arg2,arg3);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 resultobj = SWIG_Py_Void();
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
11012 int argc;
11013 PyObject *argv[4];
11014
11015 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
11016 --argc;
11017 if (argc == 2) {
11018 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
11019 }
11020 if (argc == 3) {
11021 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
11022 }
11023
11024 fail:
11025 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11026 return NULL;
11027 }
11028
11029
11030 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11031 PyObject *resultobj = 0;
11032 wxRect2D *arg1 = (wxRect2D *) 0 ;
11033 PyObject *arg2 = (PyObject *) 0 ;
11034 bool result;
11035 void *argp1 = 0 ;
11036 int res1 = 0 ;
11037 PyObject * obj0 = 0 ;
11038 PyObject * obj1 = 0 ;
11039 char * kwnames[] = {
11040 (char *) "self",(char *) "other", NULL
11041 };
11042
11043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11045 if (!SWIG_IsOK(res1)) {
11046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11047 }
11048 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11049 arg2 = obj1;
11050 {
11051 result = (bool)wxRect2D___eq__(arg1,arg2);
11052 if (PyErr_Occurred()) SWIG_fail;
11053 }
11054 {
11055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11056 }
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11064 PyObject *resultobj = 0;
11065 wxRect2D *arg1 = (wxRect2D *) 0 ;
11066 PyObject *arg2 = (PyObject *) 0 ;
11067 bool result;
11068 void *argp1 = 0 ;
11069 int res1 = 0 ;
11070 PyObject * obj0 = 0 ;
11071 PyObject * obj1 = 0 ;
11072 char * kwnames[] = {
11073 (char *) "self",(char *) "other", NULL
11074 };
11075
11076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11078 if (!SWIG_IsOK(res1)) {
11079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11080 }
11081 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11082 arg2 = obj1;
11083 {
11084 result = (bool)wxRect2D___ne__(arg1,arg2);
11085 if (PyErr_Occurred()) SWIG_fail;
11086 }
11087 {
11088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11089 }
11090 return resultobj;
11091 fail:
11092 return NULL;
11093 }
11094
11095
11096 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11097 PyObject *resultobj = 0;
11098 wxRect2D *arg1 = (wxRect2D *) 0 ;
11099 wxDouble arg2 ;
11100 void *argp1 = 0 ;
11101 int res1 = 0 ;
11102 void *argp2 ;
11103 int res2 = 0 ;
11104 PyObject *swig_obj[2] ;
11105
11106 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11108 if (!SWIG_IsOK(res1)) {
11109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11110 }
11111 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11112 {
11113 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11114 if (!SWIG_IsOK(res2)) {
11115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11116 }
11117 if (!argp2) {
11118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11119 } else {
11120 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11121 arg2 = *temp;
11122 if (SWIG_IsNewObj(res2)) delete temp;
11123 }
11124 }
11125 if (arg1) (arg1)->m_x = arg2;
11126
11127 resultobj = SWIG_Py_Void();
11128 return resultobj;
11129 fail:
11130 return NULL;
11131 }
11132
11133
11134 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11135 PyObject *resultobj = 0;
11136 wxRect2D *arg1 = (wxRect2D *) 0 ;
11137 wxDouble result;
11138 void *argp1 = 0 ;
11139 int res1 = 0 ;
11140 PyObject *swig_obj[1] ;
11141
11142 if (!args) SWIG_fail;
11143 swig_obj[0] = args;
11144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11145 if (!SWIG_IsOK(res1)) {
11146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11147 }
11148 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11149 result = ((arg1)->m_x);
11150 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11158 PyObject *resultobj = 0;
11159 wxRect2D *arg1 = (wxRect2D *) 0 ;
11160 wxDouble arg2 ;
11161 void *argp1 = 0 ;
11162 int res1 = 0 ;
11163 void *argp2 ;
11164 int res2 = 0 ;
11165 PyObject *swig_obj[2] ;
11166
11167 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11169 if (!SWIG_IsOK(res1)) {
11170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11171 }
11172 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11173 {
11174 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11175 if (!SWIG_IsOK(res2)) {
11176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11177 }
11178 if (!argp2) {
11179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11180 } else {
11181 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11182 arg2 = *temp;
11183 if (SWIG_IsNewObj(res2)) delete temp;
11184 }
11185 }
11186 if (arg1) (arg1)->m_y = arg2;
11187
11188 resultobj = SWIG_Py_Void();
11189 return resultobj;
11190 fail:
11191 return NULL;
11192 }
11193
11194
11195 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11196 PyObject *resultobj = 0;
11197 wxRect2D *arg1 = (wxRect2D *) 0 ;
11198 wxDouble result;
11199 void *argp1 = 0 ;
11200 int res1 = 0 ;
11201 PyObject *swig_obj[1] ;
11202
11203 if (!args) SWIG_fail;
11204 swig_obj[0] = args;
11205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11206 if (!SWIG_IsOK(res1)) {
11207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11208 }
11209 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11210 result = ((arg1)->m_y);
11211 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11212 return resultobj;
11213 fail:
11214 return NULL;
11215 }
11216
11217
11218 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11219 PyObject *resultobj = 0;
11220 wxRect2D *arg1 = (wxRect2D *) 0 ;
11221 wxDouble arg2 ;
11222 void *argp1 = 0 ;
11223 int res1 = 0 ;
11224 void *argp2 ;
11225 int res2 = 0 ;
11226 PyObject *swig_obj[2] ;
11227
11228 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11230 if (!SWIG_IsOK(res1)) {
11231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11232 }
11233 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11234 {
11235 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11236 if (!SWIG_IsOK(res2)) {
11237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11238 }
11239 if (!argp2) {
11240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11241 } else {
11242 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11243 arg2 = *temp;
11244 if (SWIG_IsNewObj(res2)) delete temp;
11245 }
11246 }
11247 if (arg1) (arg1)->m_width = arg2;
11248
11249 resultobj = SWIG_Py_Void();
11250 return resultobj;
11251 fail:
11252 return NULL;
11253 }
11254
11255
11256 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257 PyObject *resultobj = 0;
11258 wxRect2D *arg1 = (wxRect2D *) 0 ;
11259 wxDouble result;
11260 void *argp1 = 0 ;
11261 int res1 = 0 ;
11262 PyObject *swig_obj[1] ;
11263
11264 if (!args) SWIG_fail;
11265 swig_obj[0] = args;
11266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11267 if (!SWIG_IsOK(res1)) {
11268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11269 }
11270 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11271 result = ((arg1)->m_width);
11272 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11273 return resultobj;
11274 fail:
11275 return NULL;
11276 }
11277
11278
11279 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11280 PyObject *resultobj = 0;
11281 wxRect2D *arg1 = (wxRect2D *) 0 ;
11282 wxDouble arg2 ;
11283 void *argp1 = 0 ;
11284 int res1 = 0 ;
11285 void *argp2 ;
11286 int res2 = 0 ;
11287 PyObject *swig_obj[2] ;
11288
11289 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11291 if (!SWIG_IsOK(res1)) {
11292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11293 }
11294 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11295 {
11296 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11297 if (!SWIG_IsOK(res2)) {
11298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11299 }
11300 if (!argp2) {
11301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11302 } else {
11303 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11304 arg2 = *temp;
11305 if (SWIG_IsNewObj(res2)) delete temp;
11306 }
11307 }
11308 if (arg1) (arg1)->m_height = arg2;
11309
11310 resultobj = SWIG_Py_Void();
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11318 PyObject *resultobj = 0;
11319 wxRect2D *arg1 = (wxRect2D *) 0 ;
11320 wxDouble result;
11321 void *argp1 = 0 ;
11322 int res1 = 0 ;
11323 PyObject *swig_obj[1] ;
11324
11325 if (!args) SWIG_fail;
11326 swig_obj[0] = args;
11327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11328 if (!SWIG_IsOK(res1)) {
11329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11330 }
11331 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11332 result = ((arg1)->m_height);
11333 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11334 return resultobj;
11335 fail:
11336 return NULL;
11337 }
11338
11339
11340 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11341 PyObject *resultobj = 0;
11342 wxRect2D *arg1 = (wxRect2D *) 0 ;
11343 wxDouble arg2 = (wxDouble) 0 ;
11344 wxDouble arg3 = (wxDouble) 0 ;
11345 wxDouble arg4 = (wxDouble) 0 ;
11346 wxDouble arg5 = (wxDouble) 0 ;
11347 void *argp1 = 0 ;
11348 int res1 = 0 ;
11349 void *argp2 ;
11350 int res2 = 0 ;
11351 void *argp3 ;
11352 int res3 = 0 ;
11353 void *argp4 ;
11354 int res4 = 0 ;
11355 void *argp5 ;
11356 int res5 = 0 ;
11357 PyObject * obj0 = 0 ;
11358 PyObject * obj1 = 0 ;
11359 PyObject * obj2 = 0 ;
11360 PyObject * obj3 = 0 ;
11361 PyObject * obj4 = 0 ;
11362 char * kwnames[] = {
11363 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11364 };
11365
11366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11368 if (!SWIG_IsOK(res1)) {
11369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11370 }
11371 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11372 if (obj1) {
11373 {
11374 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11375 if (!SWIG_IsOK(res2)) {
11376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11377 }
11378 if (!argp2) {
11379 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11380 } else {
11381 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11382 arg2 = *temp;
11383 if (SWIG_IsNewObj(res2)) delete temp;
11384 }
11385 }
11386 }
11387 if (obj2) {
11388 {
11389 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11390 if (!SWIG_IsOK(res3)) {
11391 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11392 }
11393 if (!argp3) {
11394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11395 } else {
11396 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11397 arg3 = *temp;
11398 if (SWIG_IsNewObj(res3)) delete temp;
11399 }
11400 }
11401 }
11402 if (obj3) {
11403 {
11404 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11405 if (!SWIG_IsOK(res4)) {
11406 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11407 }
11408 if (!argp4) {
11409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11410 } else {
11411 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11412 arg4 = *temp;
11413 if (SWIG_IsNewObj(res4)) delete temp;
11414 }
11415 }
11416 }
11417 if (obj4) {
11418 {
11419 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11420 if (!SWIG_IsOK(res5)) {
11421 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11422 }
11423 if (!argp5) {
11424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11425 } else {
11426 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11427 arg5 = *temp;
11428 if (SWIG_IsNewObj(res5)) delete temp;
11429 }
11430 }
11431 }
11432 {
11433 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11434 if (PyErr_Occurred()) SWIG_fail;
11435 }
11436 resultobj = SWIG_Py_Void();
11437 return resultobj;
11438 fail:
11439 return NULL;
11440 }
11441
11442
11443 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11444 PyObject *resultobj = 0;
11445 wxRect2D *arg1 = (wxRect2D *) 0 ;
11446 PyObject *result = 0 ;
11447 void *argp1 = 0 ;
11448 int res1 = 0 ;
11449 PyObject *swig_obj[1] ;
11450
11451 if (!args) SWIG_fail;
11452 swig_obj[0] = args;
11453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11454 if (!SWIG_IsOK(res1)) {
11455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11456 }
11457 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11458 {
11459 result = (PyObject *)wxRect2D_Get(arg1);
11460 if (PyErr_Occurred()) SWIG_fail;
11461 }
11462 resultobj = result;
11463 return resultobj;
11464 fail:
11465 return NULL;
11466 }
11467
11468
11469 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11470 PyObject *obj;
11471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11472 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11473 return SWIG_Py_Void();
11474 }
11475
11476 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11477 return SWIG_Python_InitShadowInstance(args);
11478 }
11479
11480 SWIGINTERN PyObject *_wrap_new_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11481 PyObject *resultobj = 0;
11482 int arg1 = (int) 0 ;
11483 int arg2 = (int) 0 ;
11484 wxPosition *result = 0 ;
11485 int val1 ;
11486 int ecode1 = 0 ;
11487 int val2 ;
11488 int ecode2 = 0 ;
11489 PyObject * obj0 = 0 ;
11490 PyObject * obj1 = 0 ;
11491 char * kwnames[] = {
11492 (char *) "row",(char *) "col", NULL
11493 };
11494
11495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Position",kwnames,&obj0,&obj1)) SWIG_fail;
11496 if (obj0) {
11497 ecode1 = SWIG_AsVal_int(obj0, &val1);
11498 if (!SWIG_IsOK(ecode1)) {
11499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Position" "', expected argument " "1"" of type '" "int""'");
11500 }
11501 arg1 = static_cast< int >(val1);
11502 }
11503 if (obj1) {
11504 ecode2 = SWIG_AsVal_int(obj1, &val2);
11505 if (!SWIG_IsOK(ecode2)) {
11506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Position" "', expected argument " "2"" of type '" "int""'");
11507 }
11508 arg2 = static_cast< int >(val2);
11509 }
11510 {
11511 result = (wxPosition *)new wxPosition(arg1,arg2);
11512 if (PyErr_Occurred()) SWIG_fail;
11513 }
11514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPosition, SWIG_POINTER_NEW | 0 );
11515 return resultobj;
11516 fail:
11517 return NULL;
11518 }
11519
11520
11521 SWIGINTERN PyObject *_wrap_delete_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11522 PyObject *resultobj = 0;
11523 wxPosition *arg1 = (wxPosition *) 0 ;
11524 void *argp1 = 0 ;
11525 int res1 = 0 ;
11526 PyObject *swig_obj[1] ;
11527
11528 if (!args) SWIG_fail;
11529 swig_obj[0] = args;
11530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, SWIG_POINTER_DISOWN | 0 );
11531 if (!SWIG_IsOK(res1)) {
11532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Position" "', expected argument " "1"" of type '" "wxPosition *""'");
11533 }
11534 arg1 = reinterpret_cast< wxPosition * >(argp1);
11535 {
11536 delete arg1;
11537
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 resultobj = SWIG_Py_Void();
11541 return resultobj;
11542 fail:
11543 return NULL;
11544 }
11545
11546
11547 SWIGINTERN PyObject *_wrap_Position_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11548 PyObject *resultobj = 0;
11549 wxPosition *arg1 = (wxPosition *) 0 ;
11550 int result;
11551 void *argp1 = 0 ;
11552 int res1 = 0 ;
11553 PyObject *swig_obj[1] ;
11554
11555 if (!args) SWIG_fail;
11556 swig_obj[0] = args;
11557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11558 if (!SWIG_IsOK(res1)) {
11559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetRow" "', expected argument " "1"" of type '" "wxPosition const *""'");
11560 }
11561 arg1 = reinterpret_cast< wxPosition * >(argp1);
11562 {
11563 result = (int)((wxPosition const *)arg1)->GetRow();
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 resultobj = SWIG_From_int(static_cast< int >(result));
11567 return resultobj;
11568 fail:
11569 return NULL;
11570 }
11571
11572
11573 SWIGINTERN PyObject *_wrap_Position_GetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11574 PyObject *resultobj = 0;
11575 wxPosition *arg1 = (wxPosition *) 0 ;
11576 int result;
11577 void *argp1 = 0 ;
11578 int res1 = 0 ;
11579 PyObject *swig_obj[1] ;
11580
11581 if (!args) SWIG_fail;
11582 swig_obj[0] = args;
11583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11584 if (!SWIG_IsOK(res1)) {
11585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetColumn" "', expected argument " "1"" of type '" "wxPosition const *""'");
11586 }
11587 arg1 = reinterpret_cast< wxPosition * >(argp1);
11588 {
11589 result = (int)((wxPosition const *)arg1)->GetColumn();
11590 if (PyErr_Occurred()) SWIG_fail;
11591 }
11592 resultobj = SWIG_From_int(static_cast< int >(result));
11593 return resultobj;
11594 fail:
11595 return NULL;
11596 }
11597
11598
11599 SWIGINTERN PyObject *_wrap_Position_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11600 PyObject *resultobj = 0;
11601 wxPosition *arg1 = (wxPosition *) 0 ;
11602 int result;
11603 void *argp1 = 0 ;
11604 int res1 = 0 ;
11605 PyObject *swig_obj[1] ;
11606
11607 if (!args) SWIG_fail;
11608 swig_obj[0] = args;
11609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11610 if (!SWIG_IsOK(res1)) {
11611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetCol" "', expected argument " "1"" of type '" "wxPosition const *""'");
11612 }
11613 arg1 = reinterpret_cast< wxPosition * >(argp1);
11614 {
11615 result = (int)((wxPosition const *)arg1)->GetCol();
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 resultobj = SWIG_From_int(static_cast< int >(result));
11619 return resultobj;
11620 fail:
11621 return NULL;
11622 }
11623
11624
11625 SWIGINTERN PyObject *_wrap_Position_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj = 0;
11627 wxPosition *arg1 = (wxPosition *) 0 ;
11628 int arg2 ;
11629 void *argp1 = 0 ;
11630 int res1 = 0 ;
11631 int val2 ;
11632 int ecode2 = 0 ;
11633 PyObject * obj0 = 0 ;
11634 PyObject * obj1 = 0 ;
11635 char * kwnames[] = {
11636 (char *) "self",(char *) "row", NULL
11637 };
11638
11639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
11640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11641 if (!SWIG_IsOK(res1)) {
11642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetRow" "', expected argument " "1"" of type '" "wxPosition *""'");
11643 }
11644 arg1 = reinterpret_cast< wxPosition * >(argp1);
11645 ecode2 = SWIG_AsVal_int(obj1, &val2);
11646 if (!SWIG_IsOK(ecode2)) {
11647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetRow" "', expected argument " "2"" of type '" "int""'");
11648 }
11649 arg2 = static_cast< int >(val2);
11650 {
11651 (arg1)->SetRow(arg2);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 resultobj = SWIG_Py_Void();
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 SWIGINTERN PyObject *_wrap_Position_SetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj = 0;
11663 wxPosition *arg1 = (wxPosition *) 0 ;
11664 int arg2 ;
11665 void *argp1 = 0 ;
11666 int res1 = 0 ;
11667 int val2 ;
11668 int ecode2 = 0 ;
11669 PyObject * obj0 = 0 ;
11670 PyObject * obj1 = 0 ;
11671 char * kwnames[] = {
11672 (char *) "self",(char *) "column", NULL
11673 };
11674
11675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetColumn",kwnames,&obj0,&obj1)) SWIG_fail;
11676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11677 if (!SWIG_IsOK(res1)) {
11678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetColumn" "', expected argument " "1"" of type '" "wxPosition *""'");
11679 }
11680 arg1 = reinterpret_cast< wxPosition * >(argp1);
11681 ecode2 = SWIG_AsVal_int(obj1, &val2);
11682 if (!SWIG_IsOK(ecode2)) {
11683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetColumn" "', expected argument " "2"" of type '" "int""'");
11684 }
11685 arg2 = static_cast< int >(val2);
11686 {
11687 (arg1)->SetColumn(arg2);
11688 if (PyErr_Occurred()) SWIG_fail;
11689 }
11690 resultobj = SWIG_Py_Void();
11691 return resultobj;
11692 fail:
11693 return NULL;
11694 }
11695
11696
11697 SWIGINTERN PyObject *_wrap_Position_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11698 PyObject *resultobj = 0;
11699 wxPosition *arg1 = (wxPosition *) 0 ;
11700 int arg2 ;
11701 void *argp1 = 0 ;
11702 int res1 = 0 ;
11703 int val2 ;
11704 int ecode2 = 0 ;
11705 PyObject * obj0 = 0 ;
11706 PyObject * obj1 = 0 ;
11707 char * kwnames[] = {
11708 (char *) "self",(char *) "column", NULL
11709 };
11710
11711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
11712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11713 if (!SWIG_IsOK(res1)) {
11714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetCol" "', expected argument " "1"" of type '" "wxPosition *""'");
11715 }
11716 arg1 = reinterpret_cast< wxPosition * >(argp1);
11717 ecode2 = SWIG_AsVal_int(obj1, &val2);
11718 if (!SWIG_IsOK(ecode2)) {
11719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetCol" "', expected argument " "2"" of type '" "int""'");
11720 }
11721 arg2 = static_cast< int >(val2);
11722 {
11723 (arg1)->SetCol(arg2);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 resultobj = SWIG_Py_Void();
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 SWIGINTERN PyObject *_wrap_Position___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11734 PyObject *resultobj = 0;
11735 wxPosition *arg1 = (wxPosition *) 0 ;
11736 PyObject *arg2 = (PyObject *) 0 ;
11737 bool result;
11738 void *argp1 = 0 ;
11739 int res1 = 0 ;
11740 PyObject * obj0 = 0 ;
11741 PyObject * obj1 = 0 ;
11742 char * kwnames[] = {
11743 (char *) "self",(char *) "other", NULL
11744 };
11745
11746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11748 if (!SWIG_IsOK(res1)) {
11749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___eq__" "', expected argument " "1"" of type '" "wxPosition *""'");
11750 }
11751 arg1 = reinterpret_cast< wxPosition * >(argp1);
11752 arg2 = obj1;
11753 {
11754 result = (bool)wxPosition___eq__(arg1,arg2);
11755 if (PyErr_Occurred()) SWIG_fail;
11756 }
11757 {
11758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11759 }
11760 return resultobj;
11761 fail:
11762 return NULL;
11763 }
11764
11765
11766 SWIGINTERN PyObject *_wrap_Position___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11767 PyObject *resultobj = 0;
11768 wxPosition *arg1 = (wxPosition *) 0 ;
11769 PyObject *arg2 = (PyObject *) 0 ;
11770 bool result;
11771 void *argp1 = 0 ;
11772 int res1 = 0 ;
11773 PyObject * obj0 = 0 ;
11774 PyObject * obj1 = 0 ;
11775 char * kwnames[] = {
11776 (char *) "self",(char *) "other", NULL
11777 };
11778
11779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11781 if (!SWIG_IsOK(res1)) {
11782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___ne__" "', expected argument " "1"" of type '" "wxPosition *""'");
11783 }
11784 arg1 = reinterpret_cast< wxPosition * >(argp1);
11785 arg2 = obj1;
11786 {
11787 result = (bool)wxPosition___ne__(arg1,arg2);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11792 }
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 SWIGINTERN PyObject *_wrap_Position___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11800 PyObject *resultobj = 0;
11801 wxPosition *arg1 = (wxPosition *) 0 ;
11802 wxPosition *arg2 = 0 ;
11803 wxPosition result;
11804 void *argp1 = 0 ;
11805 int res1 = 0 ;
11806 void *argp2 = 0 ;
11807 int res2 = 0 ;
11808
11809 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11811 if (!SWIG_IsOK(res1)) {
11812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11813 }
11814 arg1 = reinterpret_cast< wxPosition * >(argp1);
11815 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11816 if (!SWIG_IsOK(res2)) {
11817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11818 }
11819 if (!argp2) {
11820 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11821 }
11822 arg2 = reinterpret_cast< wxPosition * >(argp2);
11823 {
11824 result = ((wxPosition const *)arg1)->operator +((wxPosition const &)*arg2);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11828 return resultobj;
11829 fail:
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11835 PyObject *resultobj = 0;
11836 wxPosition *arg1 = (wxPosition *) 0 ;
11837 wxPosition *arg2 = 0 ;
11838 wxPosition result;
11839 void *argp1 = 0 ;
11840 int res1 = 0 ;
11841 void *argp2 = 0 ;
11842 int res2 = 0 ;
11843
11844 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11846 if (!SWIG_IsOK(res1)) {
11847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11848 }
11849 arg1 = reinterpret_cast< wxPosition * >(argp1);
11850 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11851 if (!SWIG_IsOK(res2)) {
11852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11853 }
11854 if (!argp2) {
11855 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11856 }
11857 arg2 = reinterpret_cast< wxPosition * >(argp2);
11858 {
11859 result = ((wxPosition const *)arg1)->operator -((wxPosition const &)*arg2);
11860 if (PyErr_Occurred()) SWIG_fail;
11861 }
11862 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11863 return resultobj;
11864 fail:
11865 return NULL;
11866 }
11867
11868
11869 SWIGINTERN PyObject *_wrap_Position___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11870 PyObject *resultobj = 0;
11871 wxPosition *arg1 = (wxPosition *) 0 ;
11872 wxSize *arg2 = 0 ;
11873 wxPosition result;
11874 void *argp1 = 0 ;
11875 int res1 = 0 ;
11876 wxSize temp2 ;
11877
11878 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11880 if (!SWIG_IsOK(res1)) {
11881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11882 }
11883 arg1 = reinterpret_cast< wxPosition * >(argp1);
11884 {
11885 arg2 = &temp2;
11886 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11887 }
11888 {
11889 result = ((wxPosition const *)arg1)->operator +((wxSize const &)*arg2);
11890 if (PyErr_Occurred()) SWIG_fail;
11891 }
11892 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11893 return resultobj;
11894 fail:
11895 return NULL;
11896 }
11897
11898
11899 SWIGINTERN PyObject *_wrap_Position___add__(PyObject *self, PyObject *args) {
11900 int argc;
11901 PyObject *argv[3];
11902
11903 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___add__",0,2,argv))) SWIG_fail;
11904 --argc;
11905 if (argc == 2) {
11906 int _v = 0;
11907 {
11908 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11909 _v = SWIG_CheckState(res);
11910 }
11911 if (!_v) goto check_1;
11912 return _wrap_Position___add____SWIG_0(self, argc, argv);
11913 }
11914 check_1:
11915
11916 if (argc == 2) {
11917 return _wrap_Position___add____SWIG_1(self, argc, argv);
11918 }
11919
11920 fail:
11921 Py_INCREF(Py_NotImplemented);
11922 return Py_NotImplemented;
11923 }
11924
11925
11926 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11927 PyObject *resultobj = 0;
11928 wxPosition *arg1 = (wxPosition *) 0 ;
11929 wxSize *arg2 = 0 ;
11930 wxPosition result;
11931 void *argp1 = 0 ;
11932 int res1 = 0 ;
11933 wxSize temp2 ;
11934
11935 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11937 if (!SWIG_IsOK(res1)) {
11938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11939 }
11940 arg1 = reinterpret_cast< wxPosition * >(argp1);
11941 {
11942 arg2 = &temp2;
11943 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11944 }
11945 {
11946 result = ((wxPosition const *)arg1)->operator -((wxSize const &)*arg2);
11947 if (PyErr_Occurred()) SWIG_fail;
11948 }
11949 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11950 return resultobj;
11951 fail:
11952 return NULL;
11953 }
11954
11955
11956 SWIGINTERN PyObject *_wrap_Position___sub__(PyObject *self, PyObject *args) {
11957 int argc;
11958 PyObject *argv[3];
11959
11960 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___sub__",0,2,argv))) SWIG_fail;
11961 --argc;
11962 if (argc == 2) {
11963 int _v = 0;
11964 {
11965 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11966 _v = SWIG_CheckState(res);
11967 }
11968 if (!_v) goto check_1;
11969 return _wrap_Position___sub____SWIG_0(self, argc, argv);
11970 }
11971 check_1:
11972
11973 if (argc == 2) {
11974 return _wrap_Position___sub____SWIG_1(self, argc, argv);
11975 }
11976
11977 fail:
11978 Py_INCREF(Py_NotImplemented);
11979 return Py_NotImplemented;
11980 }
11981
11982
11983 SWIGINTERN PyObject *Position_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11984 PyObject *obj;
11985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11986 SWIG_TypeNewClientData(SWIGTYPE_p_wxPosition, SWIG_NewClientData(obj));
11987 return SWIG_Py_Void();
11988 }
11989
11990 SWIGINTERN PyObject *Position_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11991 return SWIG_Python_InitShadowInstance(args);
11992 }
11993
11994 SWIGINTERN int DefaultPosition_set(PyObject *) {
11995 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11996 return 1;
11997 }
11998
11999
12000 SWIGINTERN PyObject *DefaultPosition_get(void) {
12001 PyObject *pyobj = 0;
12002
12003 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
12004 return pyobj;
12005 }
12006
12007
12008 SWIGINTERN int DefaultSize_set(PyObject *) {
12009 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
12010 return 1;
12011 }
12012
12013
12014 SWIGINTERN PyObject *DefaultSize_get(void) {
12015 PyObject *pyobj = 0;
12016
12017 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
12018 return pyobj;
12019 }
12020
12021
12022 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj = 0;
12024 PyObject *arg1 = (PyObject *) 0 ;
12025 wxPyInputStream *result = 0 ;
12026 PyObject * obj0 = 0 ;
12027 char * kwnames[] = {
12028 (char *) "p", NULL
12029 };
12030
12031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
12032 arg1 = obj0;
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
12036 wxPyEndAllowThreads(__tstate);
12037 if (PyErr_Occurred()) SWIG_fail;
12038 }
12039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
12040 return resultobj;
12041 fail:
12042 return NULL;
12043 }
12044
12045
12046 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12047 PyObject *resultobj = 0;
12048 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12049 void *argp1 = 0 ;
12050 int res1 = 0 ;
12051 PyObject *swig_obj[1] ;
12052
12053 if (!args) SWIG_fail;
12054 swig_obj[0] = args;
12055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
12056 if (!SWIG_IsOK(res1)) {
12057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12058 }
12059 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 delete arg1;
12063
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 resultobj = SWIG_Py_Void();
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12075 PyObject *resultobj = 0;
12076 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12077 void *argp1 = 0 ;
12078 int res1 = 0 ;
12079 PyObject *swig_obj[1] ;
12080
12081 if (!args) SWIG_fail;
12082 swig_obj[0] = args;
12083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12084 if (!SWIG_IsOK(res1)) {
12085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12086 }
12087 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 (arg1)->close();
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 resultobj = SWIG_Py_Void();
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 PyObject *resultobj = 0;
12103 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12104 void *argp1 = 0 ;
12105 int res1 = 0 ;
12106 PyObject *swig_obj[1] ;
12107
12108 if (!args) SWIG_fail;
12109 swig_obj[0] = args;
12110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12111 if (!SWIG_IsOK(res1)) {
12112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12113 }
12114 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12115 {
12116 PyThreadState* __tstate = wxPyBeginAllowThreads();
12117 (arg1)->flush();
12118 wxPyEndAllowThreads(__tstate);
12119 if (PyErr_Occurred()) SWIG_fail;
12120 }
12121 resultobj = SWIG_Py_Void();
12122 return resultobj;
12123 fail:
12124 return NULL;
12125 }
12126
12127
12128 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12129 PyObject *resultobj = 0;
12130 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12131 bool result;
12132 void *argp1 = 0 ;
12133 int res1 = 0 ;
12134 PyObject *swig_obj[1] ;
12135
12136 if (!args) SWIG_fail;
12137 swig_obj[0] = args;
12138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12139 if (!SWIG_IsOK(res1)) {
12140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12141 }
12142 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12143 {
12144 PyThreadState* __tstate = wxPyBeginAllowThreads();
12145 result = (bool)(arg1)->eof();
12146 wxPyEndAllowThreads(__tstate);
12147 if (PyErr_Occurred()) SWIG_fail;
12148 }
12149 {
12150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12151 }
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12159 PyObject *resultobj = 0;
12160 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12161 int arg2 = (int) -1 ;
12162 PyObject *result = 0 ;
12163 void *argp1 = 0 ;
12164 int res1 = 0 ;
12165 int val2 ;
12166 int ecode2 = 0 ;
12167 PyObject * obj0 = 0 ;
12168 PyObject * obj1 = 0 ;
12169 char * kwnames[] = {
12170 (char *) "self",(char *) "size", NULL
12171 };
12172
12173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
12174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12175 if (!SWIG_IsOK(res1)) {
12176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12177 }
12178 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12179 if (obj1) {
12180 ecode2 = SWIG_AsVal_int(obj1, &val2);
12181 if (!SWIG_IsOK(ecode2)) {
12182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
12183 }
12184 arg2 = static_cast< int >(val2);
12185 }
12186 {
12187 PyThreadState* __tstate = wxPyBeginAllowThreads();
12188 result = (PyObject *)(arg1)->read(arg2);
12189 wxPyEndAllowThreads(__tstate);
12190 if (PyErr_Occurred()) SWIG_fail;
12191 }
12192 resultobj = result;
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12200 PyObject *resultobj = 0;
12201 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12202 int arg2 = (int) -1 ;
12203 PyObject *result = 0 ;
12204 void *argp1 = 0 ;
12205 int res1 = 0 ;
12206 int val2 ;
12207 int ecode2 = 0 ;
12208 PyObject * obj0 = 0 ;
12209 PyObject * obj1 = 0 ;
12210 char * kwnames[] = {
12211 (char *) "self",(char *) "size", NULL
12212 };
12213
12214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
12215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12216 if (!SWIG_IsOK(res1)) {
12217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12218 }
12219 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12220 if (obj1) {
12221 ecode2 = SWIG_AsVal_int(obj1, &val2);
12222 if (!SWIG_IsOK(ecode2)) {
12223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
12224 }
12225 arg2 = static_cast< int >(val2);
12226 }
12227 {
12228 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 result = (PyObject *)(arg1)->readline(arg2);
12230 wxPyEndAllowThreads(__tstate);
12231 if (PyErr_Occurred()) SWIG_fail;
12232 }
12233 resultobj = result;
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj = 0;
12242 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12243 int arg2 = (int) -1 ;
12244 PyObject *result = 0 ;
12245 void *argp1 = 0 ;
12246 int res1 = 0 ;
12247 int val2 ;
12248 int ecode2 = 0 ;
12249 PyObject * obj0 = 0 ;
12250 PyObject * obj1 = 0 ;
12251 char * kwnames[] = {
12252 (char *) "self",(char *) "sizehint", NULL
12253 };
12254
12255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
12256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12257 if (!SWIG_IsOK(res1)) {
12258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12259 }
12260 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12261 if (obj1) {
12262 ecode2 = SWIG_AsVal_int(obj1, &val2);
12263 if (!SWIG_IsOK(ecode2)) {
12264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
12265 }
12266 arg2 = static_cast< int >(val2);
12267 }
12268 {
12269 PyThreadState* __tstate = wxPyBeginAllowThreads();
12270 result = (PyObject *)(arg1)->readlines(arg2);
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 resultobj = result;
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj = 0;
12283 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12284 int arg2 ;
12285 int arg3 = (int) 0 ;
12286 void *argp1 = 0 ;
12287 int res1 = 0 ;
12288 int val2 ;
12289 int ecode2 = 0 ;
12290 int val3 ;
12291 int ecode3 = 0 ;
12292 PyObject * obj0 = 0 ;
12293 PyObject * obj1 = 0 ;
12294 PyObject * obj2 = 0 ;
12295 char * kwnames[] = {
12296 (char *) "self",(char *) "offset",(char *) "whence", NULL
12297 };
12298
12299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12301 if (!SWIG_IsOK(res1)) {
12302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12303 }
12304 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12305 ecode2 = SWIG_AsVal_int(obj1, &val2);
12306 if (!SWIG_IsOK(ecode2)) {
12307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
12308 }
12309 arg2 = static_cast< int >(val2);
12310 if (obj2) {
12311 ecode3 = SWIG_AsVal_int(obj2, &val3);
12312 if (!SWIG_IsOK(ecode3)) {
12313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
12314 }
12315 arg3 = static_cast< int >(val3);
12316 }
12317 {
12318 PyThreadState* __tstate = wxPyBeginAllowThreads();
12319 (arg1)->seek(arg2,arg3);
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 resultobj = SWIG_Py_Void();
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12331 PyObject *resultobj = 0;
12332 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12333 int result;
12334 void *argp1 = 0 ;
12335 int res1 = 0 ;
12336 PyObject *swig_obj[1] ;
12337
12338 if (!args) SWIG_fail;
12339 swig_obj[0] = args;
12340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12341 if (!SWIG_IsOK(res1)) {
12342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12343 }
12344 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 result = (int)(arg1)->tell();
12348 wxPyEndAllowThreads(__tstate);
12349 if (PyErr_Occurred()) SWIG_fail;
12350 }
12351 resultobj = SWIG_From_int(static_cast< int >(result));
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12359 PyObject *resultobj = 0;
12360 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12361 char result;
12362 void *argp1 = 0 ;
12363 int res1 = 0 ;
12364 PyObject *swig_obj[1] ;
12365
12366 if (!args) SWIG_fail;
12367 swig_obj[0] = args;
12368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12369 if (!SWIG_IsOK(res1)) {
12370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12371 }
12372 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12373 {
12374 PyThreadState* __tstate = wxPyBeginAllowThreads();
12375 result = (char)(arg1)->Peek();
12376 wxPyEndAllowThreads(__tstate);
12377 if (PyErr_Occurred()) SWIG_fail;
12378 }
12379 resultobj = SWIG_From_char(static_cast< char >(result));
12380 return resultobj;
12381 fail:
12382 return NULL;
12383 }
12384
12385
12386 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12387 PyObject *resultobj = 0;
12388 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12389 char result;
12390 void *argp1 = 0 ;
12391 int res1 = 0 ;
12392 PyObject *swig_obj[1] ;
12393
12394 if (!args) SWIG_fail;
12395 swig_obj[0] = args;
12396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12397 if (!SWIG_IsOK(res1)) {
12398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12399 }
12400 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 result = (char)(arg1)->GetC();
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 resultobj = SWIG_From_char(static_cast< char >(result));
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12415 PyObject *resultobj = 0;
12416 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12417 size_t result;
12418 void *argp1 = 0 ;
12419 int res1 = 0 ;
12420 PyObject *swig_obj[1] ;
12421
12422 if (!args) SWIG_fail;
12423 swig_obj[0] = args;
12424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12425 if (!SWIG_IsOK(res1)) {
12426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12427 }
12428 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 result = (size_t)(arg1)->LastRead();
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12443 PyObject *resultobj = 0;
12444 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12445 bool result;
12446 void *argp1 = 0 ;
12447 int res1 = 0 ;
12448 PyObject *swig_obj[1] ;
12449
12450 if (!args) SWIG_fail;
12451 swig_obj[0] = args;
12452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12453 if (!SWIG_IsOK(res1)) {
12454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12455 }
12456 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 result = (bool)(arg1)->CanRead();
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 {
12464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12465 }
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12473 PyObject *resultobj = 0;
12474 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12475 bool result;
12476 void *argp1 = 0 ;
12477 int res1 = 0 ;
12478 PyObject *swig_obj[1] ;
12479
12480 if (!args) SWIG_fail;
12481 swig_obj[0] = args;
12482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12485 }
12486 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12487 {
12488 PyThreadState* __tstate = wxPyBeginAllowThreads();
12489 result = (bool)(arg1)->Eof();
12490 wxPyEndAllowThreads(__tstate);
12491 if (PyErr_Occurred()) SWIG_fail;
12492 }
12493 {
12494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12495 }
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj = 0;
12504 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12505 char arg2 ;
12506 bool result;
12507 void *argp1 = 0 ;
12508 int res1 = 0 ;
12509 char val2 ;
12510 int ecode2 = 0 ;
12511 PyObject * obj0 = 0 ;
12512 PyObject * obj1 = 0 ;
12513 char * kwnames[] = {
12514 (char *) "self",(char *) "c", NULL
12515 };
12516
12517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
12518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12519 if (!SWIG_IsOK(res1)) {
12520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12521 }
12522 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12523 ecode2 = SWIG_AsVal_char(obj1, &val2);
12524 if (!SWIG_IsOK(ecode2)) {
12525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
12526 }
12527 arg2 = static_cast< char >(val2);
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 result = (bool)(arg1)->Ungetch(arg2);
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 {
12535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12536 }
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj = 0;
12545 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12546 long arg2 ;
12547 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12548 long result;
12549 void *argp1 = 0 ;
12550 int res1 = 0 ;
12551 long val2 ;
12552 int ecode2 = 0 ;
12553 int val3 ;
12554 int ecode3 = 0 ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 PyObject * obj2 = 0 ;
12558 char * kwnames[] = {
12559 (char *) "self",(char *) "pos",(char *) "mode", NULL
12560 };
12561
12562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12564 if (!SWIG_IsOK(res1)) {
12565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12566 }
12567 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12568 ecode2 = SWIG_AsVal_long(obj1, &val2);
12569 if (!SWIG_IsOK(ecode2)) {
12570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12571 }
12572 arg2 = static_cast< long >(val2);
12573 if (obj2) {
12574 ecode3 = SWIG_AsVal_int(obj2, &val3);
12575 if (!SWIG_IsOK(ecode3)) {
12576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12577 }
12578 arg3 = static_cast< wxSeekMode >(val3);
12579 }
12580 {
12581 PyThreadState* __tstate = wxPyBeginAllowThreads();
12582 result = (long)(arg1)->SeekI(arg2,arg3);
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 resultobj = SWIG_From_long(static_cast< long >(result));
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12594 PyObject *resultobj = 0;
12595 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12596 long result;
12597 void *argp1 = 0 ;
12598 int res1 = 0 ;
12599 PyObject *swig_obj[1] ;
12600
12601 if (!args) SWIG_fail;
12602 swig_obj[0] = args;
12603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12604 if (!SWIG_IsOK(res1)) {
12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12606 }
12607 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 result = (long)(arg1)->TellI();
12611 wxPyEndAllowThreads(__tstate);
12612 if (PyErr_Occurred()) SWIG_fail;
12613 }
12614 resultobj = SWIG_From_long(static_cast< long >(result));
12615 return resultobj;
12616 fail:
12617 return NULL;
12618 }
12619
12620
12621 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12622 PyObject *obj;
12623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12624 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12625 return SWIG_Py_Void();
12626 }
12627
12628 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12629 return SWIG_Python_InitShadowInstance(args);
12630 }
12631
12632 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12633 PyObject *resultobj = 0;
12634 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12635 PyObject *arg2 = (PyObject *) 0 ;
12636 void *argp1 = 0 ;
12637 int res1 = 0 ;
12638 PyObject * obj0 = 0 ;
12639 PyObject * obj1 = 0 ;
12640 char * kwnames[] = {
12641 (char *) "self",(char *) "obj", NULL
12642 };
12643
12644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12646 if (!SWIG_IsOK(res1)) {
12647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12648 }
12649 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12650 arg2 = obj1;
12651 {
12652 PyThreadState* __tstate = wxPyBeginAllowThreads();
12653 wxOutputStream_write(arg1,arg2);
12654 wxPyEndAllowThreads(__tstate);
12655 if (PyErr_Occurred()) SWIG_fail;
12656 }
12657 resultobj = SWIG_Py_Void();
12658 return resultobj;
12659 fail:
12660 return NULL;
12661 }
12662
12663
12664 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12665 PyObject *resultobj = 0;
12666 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12667 size_t result;
12668 void *argp1 = 0 ;
12669 int res1 = 0 ;
12670 PyObject *swig_obj[1] ;
12671
12672 if (!args) SWIG_fail;
12673 swig_obj[0] = args;
12674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12675 if (!SWIG_IsOK(res1)) {
12676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12677 }
12678 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12686 return resultobj;
12687 fail:
12688 return NULL;
12689 }
12690
12691
12692 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12693 PyObject *obj;
12694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12695 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12696 return SWIG_Py_Void();
12697 }
12698
12699 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12700 PyObject *resultobj = 0;
12701 wxInputStream *arg1 = (wxInputStream *) 0 ;
12702 wxString *arg2 = 0 ;
12703 wxString *arg3 = 0 ;
12704 wxString *arg4 = 0 ;
12705 wxDateTime arg5 ;
12706 wxFSFile *result = 0 ;
12707 wxPyInputStream *temp1 ;
12708 bool temp2 = false ;
12709 bool temp3 = false ;
12710 bool temp4 = false ;
12711 void *argp5 ;
12712 int res5 = 0 ;
12713 PyObject * obj0 = 0 ;
12714 PyObject * obj1 = 0 ;
12715 PyObject * obj2 = 0 ;
12716 PyObject * obj3 = 0 ;
12717 PyObject * obj4 = 0 ;
12718 char * kwnames[] = {
12719 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12720 };
12721
12722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12723 {
12724 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12725 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12726 } else {
12727 PyErr_Clear(); // clear the failure of the wxPyConvert above
12728 arg1 = wxPyCBInputStream_create(obj0, true);
12729 if (arg1 == NULL) {
12730 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12731 SWIG_fail;
12732 }
12733 }
12734 }
12735 {
12736 arg2 = wxString_in_helper(obj1);
12737 if (arg2 == NULL) SWIG_fail;
12738 temp2 = true;
12739 }
12740 {
12741 arg3 = wxString_in_helper(obj2);
12742 if (arg3 == NULL) SWIG_fail;
12743 temp3 = true;
12744 }
12745 {
12746 arg4 = wxString_in_helper(obj3);
12747 if (arg4 == NULL) SWIG_fail;
12748 temp4 = true;
12749 }
12750 {
12751 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12752 if (!SWIG_IsOK(res5)) {
12753 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12754 }
12755 if (!argp5) {
12756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12757 } else {
12758 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12759 arg5 = *temp;
12760 if (SWIG_IsNewObj(res5)) delete temp;
12761 }
12762 }
12763 {
12764 PyThreadState* __tstate = wxPyBeginAllowThreads();
12765 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12766 wxPyEndAllowThreads(__tstate);
12767 if (PyErr_Occurred()) SWIG_fail;
12768 }
12769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12770 {
12771 if (temp2)
12772 delete arg2;
12773 }
12774 {
12775 if (temp3)
12776 delete arg3;
12777 }
12778 {
12779 if (temp4)
12780 delete arg4;
12781 }
12782 return resultobj;
12783 fail:
12784 {
12785 if (temp2)
12786 delete arg2;
12787 }
12788 {
12789 if (temp3)
12790 delete arg3;
12791 }
12792 {
12793 if (temp4)
12794 delete arg4;
12795 }
12796 return NULL;
12797 }
12798
12799
12800 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12801 PyObject *resultobj = 0;
12802 wxFSFile *arg1 = (wxFSFile *) 0 ;
12803 void *argp1 = 0 ;
12804 int res1 = 0 ;
12805 PyObject *swig_obj[1] ;
12806
12807 if (!args) SWIG_fail;
12808 swig_obj[0] = args;
12809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12810 if (!SWIG_IsOK(res1)) {
12811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12812 }
12813 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 delete arg1;
12817
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 resultobj = SWIG_Py_Void();
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12829 PyObject *resultobj = 0;
12830 wxFSFile *arg1 = (wxFSFile *) 0 ;
12831 wxInputStream *result = 0 ;
12832 void *argp1 = 0 ;
12833 int res1 = 0 ;
12834 PyObject *swig_obj[1] ;
12835
12836 if (!args) SWIG_fail;
12837 swig_obj[0] = args;
12838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12839 if (!SWIG_IsOK(res1)) {
12840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12841 }
12842 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = (wxInputStream *)(arg1)->GetStream();
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 wxPyInputStream * _ptr = NULL;
12851
12852 if (result) {
12853 _ptr = new wxPyInputStream(result);
12854 }
12855 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12856 }
12857 return resultobj;
12858 fail:
12859 return NULL;
12860 }
12861
12862
12863 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12864 PyObject *resultobj = 0;
12865 wxFSFile *arg1 = (wxFSFile *) 0 ;
12866 void *argp1 = 0 ;
12867 int res1 = 0 ;
12868 PyObject *swig_obj[1] ;
12869
12870 if (!args) SWIG_fail;
12871 swig_obj[0] = args;
12872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12873 if (!SWIG_IsOK(res1)) {
12874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12875 }
12876 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 (arg1)->DetachStream();
12880 wxPyEndAllowThreads(__tstate);
12881 if (PyErr_Occurred()) SWIG_fail;
12882 }
12883 resultobj = SWIG_Py_Void();
12884 return resultobj;
12885 fail:
12886 return NULL;
12887 }
12888
12889
12890 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12891 PyObject *resultobj = 0;
12892 wxFSFile *arg1 = (wxFSFile *) 0 ;
12893 wxString *result = 0 ;
12894 void *argp1 = 0 ;
12895 int res1 = 0 ;
12896 PyObject *swig_obj[1] ;
12897
12898 if (!args) SWIG_fail;
12899 swig_obj[0] = args;
12900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12901 if (!SWIG_IsOK(res1)) {
12902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12903 }
12904 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12905 {
12906 PyThreadState* __tstate = wxPyBeginAllowThreads();
12907 {
12908 wxString const &_result_ref = (arg1)->GetMimeType();
12909 result = (wxString *) &_result_ref;
12910 }
12911 wxPyEndAllowThreads(__tstate);
12912 if (PyErr_Occurred()) SWIG_fail;
12913 }
12914 {
12915 #if wxUSE_UNICODE
12916 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12917 #else
12918 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12919 #endif
12920 }
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928 PyObject *resultobj = 0;
12929 wxFSFile *arg1 = (wxFSFile *) 0 ;
12930 wxString *result = 0 ;
12931 void *argp1 = 0 ;
12932 int res1 = 0 ;
12933 PyObject *swig_obj[1] ;
12934
12935 if (!args) SWIG_fail;
12936 swig_obj[0] = args;
12937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12938 if (!SWIG_IsOK(res1)) {
12939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12940 }
12941 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12942 {
12943 PyThreadState* __tstate = wxPyBeginAllowThreads();
12944 {
12945 wxString const &_result_ref = (arg1)->GetLocation();
12946 result = (wxString *) &_result_ref;
12947 }
12948 wxPyEndAllowThreads(__tstate);
12949 if (PyErr_Occurred()) SWIG_fail;
12950 }
12951 {
12952 #if wxUSE_UNICODE
12953 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12954 #else
12955 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12956 #endif
12957 }
12958 return resultobj;
12959 fail:
12960 return NULL;
12961 }
12962
12963
12964 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12965 PyObject *resultobj = 0;
12966 wxFSFile *arg1 = (wxFSFile *) 0 ;
12967 wxString *result = 0 ;
12968 void *argp1 = 0 ;
12969 int res1 = 0 ;
12970 PyObject *swig_obj[1] ;
12971
12972 if (!args) SWIG_fail;
12973 swig_obj[0] = args;
12974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12975 if (!SWIG_IsOK(res1)) {
12976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12977 }
12978 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12979 {
12980 PyThreadState* __tstate = wxPyBeginAllowThreads();
12981 {
12982 wxString const &_result_ref = (arg1)->GetAnchor();
12983 result = (wxString *) &_result_ref;
12984 }
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 {
12989 #if wxUSE_UNICODE
12990 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12991 #else
12992 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12993 #endif
12994 }
12995 return resultobj;
12996 fail:
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13002 PyObject *resultobj = 0;
13003 wxFSFile *arg1 = (wxFSFile *) 0 ;
13004 wxDateTime result;
13005 void *argp1 = 0 ;
13006 int res1 = 0 ;
13007 PyObject *swig_obj[1] ;
13008
13009 if (!args) SWIG_fail;
13010 swig_obj[0] = args;
13011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
13012 if (!SWIG_IsOK(res1)) {
13013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
13014 }
13015 arg1 = reinterpret_cast< wxFSFile * >(argp1);
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (arg1)->GetModificationTime();
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13030 PyObject *obj;
13031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13032 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
13033 return SWIG_Py_Void();
13034 }
13035
13036 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13037 return SWIG_Python_InitShadowInstance(args);
13038 }
13039
13040 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13041 PyObject *resultobj = 0;
13042 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13043 void *argp1 = 0 ;
13044 int res1 = 0 ;
13045 PyObject *swig_obj[1] ;
13046
13047 if (!args) SWIG_fail;
13048 swig_obj[0] = args;
13049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13050 if (!SWIG_IsOK(res1)) {
13051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13052 }
13053 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 delete arg1;
13057
13058 wxPyEndAllowThreads(__tstate);
13059 if (PyErr_Occurred()) SWIG_fail;
13060 }
13061 resultobj = SWIG_Py_Void();
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13069 PyObject *obj;
13070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13071 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
13072 return SWIG_Py_Void();
13073 }
13074
13075 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13076 PyObject *resultobj = 0;
13077 wxPyFileSystemHandler *result = 0 ;
13078
13079 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
13080 {
13081 PyThreadState* __tstate = wxPyBeginAllowThreads();
13082 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
13087 return resultobj;
13088 fail:
13089 return NULL;
13090 }
13091
13092
13093 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13094 PyObject *resultobj = 0;
13095 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13096 PyObject *arg2 = (PyObject *) 0 ;
13097 PyObject *arg3 = (PyObject *) 0 ;
13098 void *argp1 = 0 ;
13099 int res1 = 0 ;
13100 PyObject * obj0 = 0 ;
13101 PyObject * obj1 = 0 ;
13102 PyObject * obj2 = 0 ;
13103 char * kwnames[] = {
13104 (char *) "self",(char *) "self",(char *) "_class", NULL
13105 };
13106
13107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13109 if (!SWIG_IsOK(res1)) {
13110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13111 }
13112 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13113 arg2 = obj1;
13114 arg3 = obj2;
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 (arg1)->_setCallbackInfo(arg2,arg3);
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 resultobj = SWIG_Py_Void();
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj = 0;
13130 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13131 wxString *arg2 = 0 ;
13132 bool result;
13133 void *argp1 = 0 ;
13134 int res1 = 0 ;
13135 bool temp2 = false ;
13136 PyObject * obj0 = 0 ;
13137 PyObject * obj1 = 0 ;
13138 char * kwnames[] = {
13139 (char *) "self",(char *) "location", NULL
13140 };
13141
13142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13144 if (!SWIG_IsOK(res1)) {
13145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13146 }
13147 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13148 {
13149 arg2 = wxString_in_helper(obj1);
13150 if (arg2 == NULL) SWIG_fail;
13151 temp2 = true;
13152 }
13153 {
13154 PyThreadState* __tstate = wxPyBeginAllowThreads();
13155 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 {
13160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13161 }
13162 {
13163 if (temp2)
13164 delete arg2;
13165 }
13166 return resultobj;
13167 fail:
13168 {
13169 if (temp2)
13170 delete arg2;
13171 }
13172 return NULL;
13173 }
13174
13175
13176 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj = 0;
13178 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13179 wxFileSystem *arg2 = 0 ;
13180 wxString *arg3 = 0 ;
13181 wxFSFile *result = 0 ;
13182 void *argp1 = 0 ;
13183 int res1 = 0 ;
13184 void *argp2 = 0 ;
13185 int res2 = 0 ;
13186 bool temp3 = false ;
13187 PyObject * obj0 = 0 ;
13188 PyObject * obj1 = 0 ;
13189 PyObject * obj2 = 0 ;
13190 char * kwnames[] = {
13191 (char *) "self",(char *) "fs",(char *) "location", NULL
13192 };
13193
13194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13196 if (!SWIG_IsOK(res1)) {
13197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13198 }
13199 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13200 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13201 if (!SWIG_IsOK(res2)) {
13202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13203 }
13204 if (!argp2) {
13205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13206 }
13207 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13208 {
13209 arg3 = wxString_in_helper(obj2);
13210 if (arg3 == NULL) SWIG_fail;
13211 temp3 = true;
13212 }
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13216 wxPyEndAllowThreads(__tstate);
13217 if (PyErr_Occurred()) SWIG_fail;
13218 }
13219 {
13220 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13221 }
13222 {
13223 if (temp3)
13224 delete arg3;
13225 }
13226 return resultobj;
13227 fail:
13228 {
13229 if (temp3)
13230 delete arg3;
13231 }
13232 return NULL;
13233 }
13234
13235
13236 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13237 PyObject *resultobj = 0;
13238 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13239 wxString *arg2 = 0 ;
13240 int arg3 = (int) 0 ;
13241 wxString result;
13242 void *argp1 = 0 ;
13243 int res1 = 0 ;
13244 bool temp2 = false ;
13245 int val3 ;
13246 int ecode3 = 0 ;
13247 PyObject * obj0 = 0 ;
13248 PyObject * obj1 = 0 ;
13249 PyObject * obj2 = 0 ;
13250 char * kwnames[] = {
13251 (char *) "self",(char *) "spec",(char *) "flags", NULL
13252 };
13253
13254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13256 if (!SWIG_IsOK(res1)) {
13257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13258 }
13259 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13260 {
13261 arg2 = wxString_in_helper(obj1);
13262 if (arg2 == NULL) SWIG_fail;
13263 temp2 = true;
13264 }
13265 if (obj2) {
13266 ecode3 = SWIG_AsVal_int(obj2, &val3);
13267 if (!SWIG_IsOK(ecode3)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13269 }
13270 arg3 = static_cast< int >(val3);
13271 }
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 {
13279 #if wxUSE_UNICODE
13280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13281 #else
13282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13283 #endif
13284 }
13285 {
13286 if (temp2)
13287 delete arg2;
13288 }
13289 return resultobj;
13290 fail:
13291 {
13292 if (temp2)
13293 delete arg2;
13294 }
13295 return NULL;
13296 }
13297
13298
13299 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13300 PyObject *resultobj = 0;
13301 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13302 wxString result;
13303 void *argp1 = 0 ;
13304 int res1 = 0 ;
13305 PyObject *swig_obj[1] ;
13306
13307 if (!args) SWIG_fail;
13308 swig_obj[0] = args;
13309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13310 if (!SWIG_IsOK(res1)) {
13311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13312 }
13313 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 result = (arg1)->FindNext();
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 {
13321 #if wxUSE_UNICODE
13322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13323 #else
13324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13325 #endif
13326 }
13327 return resultobj;
13328 fail:
13329 return NULL;
13330 }
13331
13332
13333 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13334 PyObject *resultobj = 0;
13335 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13336 wxString *arg2 = 0 ;
13337 wxString result;
13338 void *argp1 = 0 ;
13339 int res1 = 0 ;
13340 bool temp2 = false ;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 char * kwnames[] = {
13344 (char *) "self",(char *) "location", NULL
13345 };
13346
13347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
13348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13349 if (!SWIG_IsOK(res1)) {
13350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13351 }
13352 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13353 {
13354 arg2 = wxString_in_helper(obj1);
13355 if (arg2 == NULL) SWIG_fail;
13356 temp2 = true;
13357 }
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (arg1)->GetProtocol((wxString const &)*arg2);
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 {
13365 #if wxUSE_UNICODE
13366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13367 #else
13368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13369 #endif
13370 }
13371 {
13372 if (temp2)
13373 delete arg2;
13374 }
13375 return resultobj;
13376 fail:
13377 {
13378 if (temp2)
13379 delete arg2;
13380 }
13381 return NULL;
13382 }
13383
13384
13385 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13386 PyObject *resultobj = 0;
13387 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13388 wxString *arg2 = 0 ;
13389 wxString result;
13390 void *argp1 = 0 ;
13391 int res1 = 0 ;
13392 bool temp2 = false ;
13393 PyObject * obj0 = 0 ;
13394 PyObject * obj1 = 0 ;
13395 char * kwnames[] = {
13396 (char *) "self",(char *) "location", NULL
13397 };
13398
13399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13403 }
13404 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13405 {
13406 arg2 = wxString_in_helper(obj1);
13407 if (arg2 == NULL) SWIG_fail;
13408 temp2 = true;
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 {
13417 #if wxUSE_UNICODE
13418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13419 #else
13420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13421 #endif
13422 }
13423 {
13424 if (temp2)
13425 delete arg2;
13426 }
13427 return resultobj;
13428 fail:
13429 {
13430 if (temp2)
13431 delete arg2;
13432 }
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13438 PyObject *resultobj = 0;
13439 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13440 wxString *arg2 = 0 ;
13441 wxString result;
13442 void *argp1 = 0 ;
13443 int res1 = 0 ;
13444 bool temp2 = false ;
13445 PyObject * obj0 = 0 ;
13446 PyObject * obj1 = 0 ;
13447 char * kwnames[] = {
13448 (char *) "self",(char *) "location", NULL
13449 };
13450
13451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
13452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13453 if (!SWIG_IsOK(res1)) {
13454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13455 }
13456 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13457 {
13458 arg2 = wxString_in_helper(obj1);
13459 if (arg2 == NULL) SWIG_fail;
13460 temp2 = true;
13461 }
13462 {
13463 PyThreadState* __tstate = wxPyBeginAllowThreads();
13464 result = (arg1)->GetAnchor((wxString const &)*arg2);
13465 wxPyEndAllowThreads(__tstate);
13466 if (PyErr_Occurred()) SWIG_fail;
13467 }
13468 {
13469 #if wxUSE_UNICODE
13470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13471 #else
13472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13473 #endif
13474 }
13475 {
13476 if (temp2)
13477 delete arg2;
13478 }
13479 return resultobj;
13480 fail:
13481 {
13482 if (temp2)
13483 delete arg2;
13484 }
13485 return NULL;
13486 }
13487
13488
13489 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13490 PyObject *resultobj = 0;
13491 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13492 wxString *arg2 = 0 ;
13493 wxString result;
13494 void *argp1 = 0 ;
13495 int res1 = 0 ;
13496 bool temp2 = false ;
13497 PyObject * obj0 = 0 ;
13498 PyObject * obj1 = 0 ;
13499 char * kwnames[] = {
13500 (char *) "self",(char *) "location", NULL
13501 };
13502
13503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13505 if (!SWIG_IsOK(res1)) {
13506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13507 }
13508 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13509 {
13510 arg2 = wxString_in_helper(obj1);
13511 if (arg2 == NULL) SWIG_fail;
13512 temp2 = true;
13513 }
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 result = (arg1)->GetRightLocation((wxString const &)*arg2);
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 {
13521 #if wxUSE_UNICODE
13522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13523 #else
13524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13525 #endif
13526 }
13527 {
13528 if (temp2)
13529 delete arg2;
13530 }
13531 return resultobj;
13532 fail:
13533 {
13534 if (temp2)
13535 delete arg2;
13536 }
13537 return NULL;
13538 }
13539
13540
13541 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj = 0;
13543 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13544 wxString *arg2 = 0 ;
13545 wxString result;
13546 void *argp1 = 0 ;
13547 int res1 = 0 ;
13548 bool temp2 = false ;
13549 PyObject * obj0 = 0 ;
13550 PyObject * obj1 = 0 ;
13551 char * kwnames[] = {
13552 (char *) "self",(char *) "location", NULL
13553 };
13554
13555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13557 if (!SWIG_IsOK(res1)) {
13558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13559 }
13560 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13561 {
13562 arg2 = wxString_in_helper(obj1);
13563 if (arg2 == NULL) SWIG_fail;
13564 temp2 = true;
13565 }
13566 {
13567 PyThreadState* __tstate = wxPyBeginAllowThreads();
13568 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13569 wxPyEndAllowThreads(__tstate);
13570 if (PyErr_Occurred()) SWIG_fail;
13571 }
13572 {
13573 #if wxUSE_UNICODE
13574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13575 #else
13576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13577 #endif
13578 }
13579 {
13580 if (temp2)
13581 delete arg2;
13582 }
13583 return resultobj;
13584 fail:
13585 {
13586 if (temp2)
13587 delete arg2;
13588 }
13589 return NULL;
13590 }
13591
13592
13593 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13594 PyObject *obj;
13595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13596 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13597 return SWIG_Py_Void();
13598 }
13599
13600 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13601 return SWIG_Python_InitShadowInstance(args);
13602 }
13603
13604 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13605 PyObject *resultobj = 0;
13606 wxFileSystem *result = 0 ;
13607
13608 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 result = (wxFileSystem *)new wxFileSystem();
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13623 PyObject *resultobj = 0;
13624 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13625 void *argp1 = 0 ;
13626 int res1 = 0 ;
13627 PyObject *swig_obj[1] ;
13628
13629 if (!args) SWIG_fail;
13630 swig_obj[0] = args;
13631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13632 if (!SWIG_IsOK(res1)) {
13633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13634 }
13635 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 delete arg1;
13639
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 resultobj = SWIG_Py_Void();
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13651 PyObject *resultobj = 0;
13652 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13653 wxString *arg2 = 0 ;
13654 bool arg3 = (bool) false ;
13655 void *argp1 = 0 ;
13656 int res1 = 0 ;
13657 bool temp2 = false ;
13658 bool val3 ;
13659 int ecode3 = 0 ;
13660 PyObject * obj0 = 0 ;
13661 PyObject * obj1 = 0 ;
13662 PyObject * obj2 = 0 ;
13663 char * kwnames[] = {
13664 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13665 };
13666
13667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13669 if (!SWIG_IsOK(res1)) {
13670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13671 }
13672 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13673 {
13674 arg2 = wxString_in_helper(obj1);
13675 if (arg2 == NULL) SWIG_fail;
13676 temp2 = true;
13677 }
13678 if (obj2) {
13679 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13680 if (!SWIG_IsOK(ecode3)) {
13681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13682 }
13683 arg3 = static_cast< bool >(val3);
13684 }
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13688 wxPyEndAllowThreads(__tstate);
13689 if (PyErr_Occurred()) SWIG_fail;
13690 }
13691 resultobj = SWIG_Py_Void();
13692 {
13693 if (temp2)
13694 delete arg2;
13695 }
13696 return resultobj;
13697 fail:
13698 {
13699 if (temp2)
13700 delete arg2;
13701 }
13702 return NULL;
13703 }
13704
13705
13706 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13707 PyObject *resultobj = 0;
13708 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13709 wxString result;
13710 void *argp1 = 0 ;
13711 int res1 = 0 ;
13712 PyObject *swig_obj[1] ;
13713
13714 if (!args) SWIG_fail;
13715 swig_obj[0] = args;
13716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13717 if (!SWIG_IsOK(res1)) {
13718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13719 }
13720 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 result = (arg1)->GetPath();
13724 wxPyEndAllowThreads(__tstate);
13725 if (PyErr_Occurred()) SWIG_fail;
13726 }
13727 {
13728 #if wxUSE_UNICODE
13729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13730 #else
13731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13732 #endif
13733 }
13734 return resultobj;
13735 fail:
13736 return NULL;
13737 }
13738
13739
13740 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13741 PyObject *resultobj = 0;
13742 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13743 wxString *arg2 = 0 ;
13744 wxFSFile *result = 0 ;
13745 void *argp1 = 0 ;
13746 int res1 = 0 ;
13747 bool temp2 = false ;
13748 PyObject * obj0 = 0 ;
13749 PyObject * obj1 = 0 ;
13750 char * kwnames[] = {
13751 (char *) "self",(char *) "location", NULL
13752 };
13753
13754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13756 if (!SWIG_IsOK(res1)) {
13757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13758 }
13759 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13760 {
13761 arg2 = wxString_in_helper(obj1);
13762 if (arg2 == NULL) SWIG_fail;
13763 temp2 = true;
13764 }
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 {
13772 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13773 }
13774 {
13775 if (temp2)
13776 delete arg2;
13777 }
13778 return resultobj;
13779 fail:
13780 {
13781 if (temp2)
13782 delete arg2;
13783 }
13784 return NULL;
13785 }
13786
13787
13788 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13789 PyObject *resultobj = 0;
13790 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13791 wxString *arg2 = 0 ;
13792 int arg3 = (int) 0 ;
13793 wxString result;
13794 void *argp1 = 0 ;
13795 int res1 = 0 ;
13796 bool temp2 = false ;
13797 int val3 ;
13798 int ecode3 = 0 ;
13799 PyObject * obj0 = 0 ;
13800 PyObject * obj1 = 0 ;
13801 PyObject * obj2 = 0 ;
13802 char * kwnames[] = {
13803 (char *) "self",(char *) "spec",(char *) "flags", NULL
13804 };
13805
13806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13808 if (!SWIG_IsOK(res1)) {
13809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13810 }
13811 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13812 {
13813 arg2 = wxString_in_helper(obj1);
13814 if (arg2 == NULL) SWIG_fail;
13815 temp2 = true;
13816 }
13817 if (obj2) {
13818 ecode3 = SWIG_AsVal_int(obj2, &val3);
13819 if (!SWIG_IsOK(ecode3)) {
13820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13821 }
13822 arg3 = static_cast< int >(val3);
13823 }
13824 {
13825 PyThreadState* __tstate = wxPyBeginAllowThreads();
13826 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13827 wxPyEndAllowThreads(__tstate);
13828 if (PyErr_Occurred()) SWIG_fail;
13829 }
13830 {
13831 #if wxUSE_UNICODE
13832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13833 #else
13834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13835 #endif
13836 }
13837 {
13838 if (temp2)
13839 delete arg2;
13840 }
13841 return resultobj;
13842 fail:
13843 {
13844 if (temp2)
13845 delete arg2;
13846 }
13847 return NULL;
13848 }
13849
13850
13851 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13852 PyObject *resultobj = 0;
13853 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13854 wxString result;
13855 void *argp1 = 0 ;
13856 int res1 = 0 ;
13857 PyObject *swig_obj[1] ;
13858
13859 if (!args) SWIG_fail;
13860 swig_obj[0] = args;
13861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13862 if (!SWIG_IsOK(res1)) {
13863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13864 }
13865 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13866 {
13867 PyThreadState* __tstate = wxPyBeginAllowThreads();
13868 result = (arg1)->FindNext();
13869 wxPyEndAllowThreads(__tstate);
13870 if (PyErr_Occurred()) SWIG_fail;
13871 }
13872 {
13873 #if wxUSE_UNICODE
13874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13875 #else
13876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13877 #endif
13878 }
13879 return resultobj;
13880 fail:
13881 return NULL;
13882 }
13883
13884
13885 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13886 PyObject *resultobj = 0;
13887 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13888 int res1 = 0 ;
13889 PyObject * obj0 = 0 ;
13890 char * kwnames[] = {
13891 (char *) "handler", NULL
13892 };
13893
13894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13895 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13896 if (!SWIG_IsOK(res1)) {
13897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13898 }
13899 {
13900 PyThreadState* __tstate = wxPyBeginAllowThreads();
13901 wxFileSystem::AddHandler(arg1);
13902 wxPyEndAllowThreads(__tstate);
13903 if (PyErr_Occurred()) SWIG_fail;
13904 }
13905 resultobj = SWIG_Py_Void();
13906 return resultobj;
13907 fail:
13908 return NULL;
13909 }
13910
13911
13912 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13913 PyObject *resultobj = 0;
13914 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13915 wxFileSystemHandler *result = 0 ;
13916 void *argp1 = 0 ;
13917 int res1 = 0 ;
13918 PyObject * obj0 = 0 ;
13919 char * kwnames[] = {
13920 (char *) "handler", NULL
13921 };
13922
13923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13925 if (!SWIG_IsOK(res1)) {
13926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13927 }
13928 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13932 wxPyEndAllowThreads(__tstate);
13933 if (PyErr_Occurred()) SWIG_fail;
13934 }
13935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13936 return resultobj;
13937 fail:
13938 return NULL;
13939 }
13940
13941
13942 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13943 PyObject *resultobj = 0;
13944
13945 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 wxFileSystem::CleanUpHandlers();
13949 wxPyEndAllowThreads(__tstate);
13950 if (PyErr_Occurred()) SWIG_fail;
13951 }
13952 resultobj = SWIG_Py_Void();
13953 return resultobj;
13954 fail:
13955 return NULL;
13956 }
13957
13958
13959 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13960 PyObject *resultobj = 0;
13961 wxString *arg1 = 0 ;
13962 wxString result;
13963 bool temp1 = false ;
13964 PyObject * obj0 = 0 ;
13965 char * kwnames[] = {
13966 (char *) "filename", NULL
13967 };
13968
13969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13970 {
13971 arg1 = wxString_in_helper(obj0);
13972 if (arg1 == NULL) SWIG_fail;
13973 temp1 = true;
13974 }
13975 {
13976 PyThreadState* __tstate = wxPyBeginAllowThreads();
13977 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13978 wxPyEndAllowThreads(__tstate);
13979 if (PyErr_Occurred()) SWIG_fail;
13980 }
13981 {
13982 #if wxUSE_UNICODE
13983 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13984 #else
13985 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13986 #endif
13987 }
13988 {
13989 if (temp1)
13990 delete arg1;
13991 }
13992 return resultobj;
13993 fail:
13994 {
13995 if (temp1)
13996 delete arg1;
13997 }
13998 return NULL;
13999 }
14000
14001
14002 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj = 0;
14004 wxString *arg1 = 0 ;
14005 wxString result;
14006 bool temp1 = false ;
14007 PyObject * obj0 = 0 ;
14008 char * kwnames[] = {
14009 (char *) "url", NULL
14010 };
14011
14012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
14013 {
14014 arg1 = wxString_in_helper(obj0);
14015 if (arg1 == NULL) SWIG_fail;
14016 temp1 = true;
14017 }
14018 {
14019 PyThreadState* __tstate = wxPyBeginAllowThreads();
14020 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 {
14025 #if wxUSE_UNICODE
14026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14027 #else
14028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14029 #endif
14030 }
14031 {
14032 if (temp1)
14033 delete arg1;
14034 }
14035 return resultobj;
14036 fail:
14037 {
14038 if (temp1)
14039 delete arg1;
14040 }
14041 return NULL;
14042 }
14043
14044
14045 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14046 PyObject *obj;
14047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14048 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
14049 return SWIG_Py_Void();
14050 }
14051
14052 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14053 return SWIG_Python_InitShadowInstance(args);
14054 }
14055
14056 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14057 PyObject *resultobj = 0;
14058 wxInternetFSHandler *result = 0 ;
14059
14060 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 result = (wxInternetFSHandler *)new wxInternetFSHandler();
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14077 wxString *arg2 = 0 ;
14078 bool result;
14079 void *argp1 = 0 ;
14080 int res1 = 0 ;
14081 bool temp2 = false ;
14082 PyObject * obj0 = 0 ;
14083 PyObject * obj1 = 0 ;
14084 char * kwnames[] = {
14085 (char *) "self",(char *) "location", NULL
14086 };
14087
14088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14090 if (!SWIG_IsOK(res1)) {
14091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14092 }
14093 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14094 {
14095 arg2 = wxString_in_helper(obj1);
14096 if (arg2 == NULL) SWIG_fail;
14097 temp2 = true;
14098 }
14099 {
14100 PyThreadState* __tstate = wxPyBeginAllowThreads();
14101 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14102 wxPyEndAllowThreads(__tstate);
14103 if (PyErr_Occurred()) SWIG_fail;
14104 }
14105 {
14106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14107 }
14108 {
14109 if (temp2)
14110 delete arg2;
14111 }
14112 return resultobj;
14113 fail:
14114 {
14115 if (temp2)
14116 delete arg2;
14117 }
14118 return NULL;
14119 }
14120
14121
14122 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14123 PyObject *resultobj = 0;
14124 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14125 wxFileSystem *arg2 = 0 ;
14126 wxString *arg3 = 0 ;
14127 wxFSFile *result = 0 ;
14128 void *argp1 = 0 ;
14129 int res1 = 0 ;
14130 void *argp2 = 0 ;
14131 int res2 = 0 ;
14132 bool temp3 = false ;
14133 PyObject * obj0 = 0 ;
14134 PyObject * obj1 = 0 ;
14135 PyObject * obj2 = 0 ;
14136 char * kwnames[] = {
14137 (char *) "self",(char *) "fs",(char *) "location", NULL
14138 };
14139
14140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14142 if (!SWIG_IsOK(res1)) {
14143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14144 }
14145 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14147 if (!SWIG_IsOK(res2)) {
14148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14149 }
14150 if (!argp2) {
14151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14152 }
14153 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14154 {
14155 arg3 = wxString_in_helper(obj2);
14156 if (arg3 == NULL) SWIG_fail;
14157 temp3 = true;
14158 }
14159 {
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14162 wxPyEndAllowThreads(__tstate);
14163 if (PyErr_Occurred()) SWIG_fail;
14164 }
14165 {
14166 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14167 }
14168 {
14169 if (temp3)
14170 delete arg3;
14171 }
14172 return resultobj;
14173 fail:
14174 {
14175 if (temp3)
14176 delete arg3;
14177 }
14178 return NULL;
14179 }
14180
14181
14182 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14183 PyObject *obj;
14184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14185 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
14186 return SWIG_Py_Void();
14187 }
14188
14189 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14190 return SWIG_Python_InitShadowInstance(args);
14191 }
14192
14193 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14194 PyObject *resultobj = 0;
14195 wxZipFSHandler *result = 0 ;
14196
14197 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
14198 {
14199 PyThreadState* __tstate = wxPyBeginAllowThreads();
14200 result = (wxZipFSHandler *)new wxZipFSHandler();
14201 wxPyEndAllowThreads(__tstate);
14202 if (PyErr_Occurred()) SWIG_fail;
14203 }
14204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
14205 return resultobj;
14206 fail:
14207 return NULL;
14208 }
14209
14210
14211 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14212 PyObject *resultobj = 0;
14213 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14214 wxString *arg2 = 0 ;
14215 bool result;
14216 void *argp1 = 0 ;
14217 int res1 = 0 ;
14218 bool temp2 = false ;
14219 PyObject * obj0 = 0 ;
14220 PyObject * obj1 = 0 ;
14221 char * kwnames[] = {
14222 (char *) "self",(char *) "location", NULL
14223 };
14224
14225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14227 if (!SWIG_IsOK(res1)) {
14228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14229 }
14230 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14231 {
14232 arg2 = wxString_in_helper(obj1);
14233 if (arg2 == NULL) SWIG_fail;
14234 temp2 = true;
14235 }
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14239 wxPyEndAllowThreads(__tstate);
14240 if (PyErr_Occurred()) SWIG_fail;
14241 }
14242 {
14243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14244 }
14245 {
14246 if (temp2)
14247 delete arg2;
14248 }
14249 return resultobj;
14250 fail:
14251 {
14252 if (temp2)
14253 delete arg2;
14254 }
14255 return NULL;
14256 }
14257
14258
14259 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14260 PyObject *resultobj = 0;
14261 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14262 wxFileSystem *arg2 = 0 ;
14263 wxString *arg3 = 0 ;
14264 wxFSFile *result = 0 ;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 void *argp2 = 0 ;
14268 int res2 = 0 ;
14269 bool temp3 = false ;
14270 PyObject * obj0 = 0 ;
14271 PyObject * obj1 = 0 ;
14272 PyObject * obj2 = 0 ;
14273 char * kwnames[] = {
14274 (char *) "self",(char *) "fs",(char *) "location", NULL
14275 };
14276
14277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14279 if (!SWIG_IsOK(res1)) {
14280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14281 }
14282 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14283 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14284 if (!SWIG_IsOK(res2)) {
14285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14286 }
14287 if (!argp2) {
14288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14289 }
14290 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14291 {
14292 arg3 = wxString_in_helper(obj2);
14293 if (arg3 == NULL) SWIG_fail;
14294 temp3 = true;
14295 }
14296 {
14297 PyThreadState* __tstate = wxPyBeginAllowThreads();
14298 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 {
14303 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14304 }
14305 {
14306 if (temp3)
14307 delete arg3;
14308 }
14309 return resultobj;
14310 fail:
14311 {
14312 if (temp3)
14313 delete arg3;
14314 }
14315 return NULL;
14316 }
14317
14318
14319 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj = 0;
14321 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14322 wxString *arg2 = 0 ;
14323 int arg3 = (int) 0 ;
14324 wxString result;
14325 void *argp1 = 0 ;
14326 int res1 = 0 ;
14327 bool temp2 = false ;
14328 int val3 ;
14329 int ecode3 = 0 ;
14330 PyObject * obj0 = 0 ;
14331 PyObject * obj1 = 0 ;
14332 PyObject * obj2 = 0 ;
14333 char * kwnames[] = {
14334 (char *) "self",(char *) "spec",(char *) "flags", NULL
14335 };
14336
14337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14339 if (!SWIG_IsOK(res1)) {
14340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14341 }
14342 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14343 {
14344 arg2 = wxString_in_helper(obj1);
14345 if (arg2 == NULL) SWIG_fail;
14346 temp2 = true;
14347 }
14348 if (obj2) {
14349 ecode3 = SWIG_AsVal_int(obj2, &val3);
14350 if (!SWIG_IsOK(ecode3)) {
14351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14352 }
14353 arg3 = static_cast< int >(val3);
14354 }
14355 {
14356 PyThreadState* __tstate = wxPyBeginAllowThreads();
14357 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14358 wxPyEndAllowThreads(__tstate);
14359 if (PyErr_Occurred()) SWIG_fail;
14360 }
14361 {
14362 #if wxUSE_UNICODE
14363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14364 #else
14365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14366 #endif
14367 }
14368 {
14369 if (temp2)
14370 delete arg2;
14371 }
14372 return resultobj;
14373 fail:
14374 {
14375 if (temp2)
14376 delete arg2;
14377 }
14378 return NULL;
14379 }
14380
14381
14382 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14383 PyObject *resultobj = 0;
14384 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14385 wxString result;
14386 void *argp1 = 0 ;
14387 int res1 = 0 ;
14388 PyObject *swig_obj[1] ;
14389
14390 if (!args) SWIG_fail;
14391 swig_obj[0] = args;
14392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14393 if (!SWIG_IsOK(res1)) {
14394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14395 }
14396 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (arg1)->FindNext();
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 {
14404 #if wxUSE_UNICODE
14405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14406 #else
14407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14408 #endif
14409 }
14410 return resultobj;
14411 fail:
14412 return NULL;
14413 }
14414
14415
14416 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14417 PyObject *obj;
14418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14419 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
14420 return SWIG_Py_Void();
14421 }
14422
14423 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14424 return SWIG_Python_InitShadowInstance(args);
14425 }
14426
14427 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14428 PyObject *resultobj = 0;
14429 wxString *arg1 = 0 ;
14430 wxImage *arg2 = 0 ;
14431 long arg3 ;
14432 bool temp1 = false ;
14433 void *argp2 = 0 ;
14434 int res2 = 0 ;
14435 long val3 ;
14436 int ecode3 = 0 ;
14437 PyObject * obj0 = 0 ;
14438 PyObject * obj1 = 0 ;
14439 PyObject * obj2 = 0 ;
14440 char * kwnames[] = {
14441 (char *) "filename",(char *) "image",(char *) "type", NULL
14442 };
14443
14444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14445 {
14446 arg1 = wxString_in_helper(obj0);
14447 if (arg1 == NULL) SWIG_fail;
14448 temp1 = true;
14449 }
14450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
14451 if (!SWIG_IsOK(res2)) {
14452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14453 }
14454 if (!argp2) {
14455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14456 }
14457 arg2 = reinterpret_cast< wxImage * >(argp2);
14458 ecode3 = SWIG_AsVal_long(obj2, &val3);
14459 if (!SWIG_IsOK(ecode3)) {
14460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
14461 }
14462 arg3 = static_cast< long >(val3);
14463 {
14464 PyThreadState* __tstate = wxPyBeginAllowThreads();
14465 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
14466 wxPyEndAllowThreads(__tstate);
14467 if (PyErr_Occurred()) SWIG_fail;
14468 }
14469 resultobj = SWIG_Py_Void();
14470 {
14471 if (temp1)
14472 delete arg1;
14473 }
14474 return resultobj;
14475 fail:
14476 {
14477 if (temp1)
14478 delete arg1;
14479 }
14480 return NULL;
14481 }
14482
14483
14484 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14485 PyObject *resultobj = 0;
14486 wxString *arg1 = 0 ;
14487 wxBitmap *arg2 = 0 ;
14488 long arg3 ;
14489 bool temp1 = false ;
14490 void *argp2 = 0 ;
14491 int res2 = 0 ;
14492 long val3 ;
14493 int ecode3 = 0 ;
14494 PyObject * obj0 = 0 ;
14495 PyObject * obj1 = 0 ;
14496 PyObject * obj2 = 0 ;
14497 char * kwnames[] = {
14498 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
14499 };
14500
14501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14502 {
14503 arg1 = wxString_in_helper(obj0);
14504 if (arg1 == NULL) SWIG_fail;
14505 temp1 = true;
14506 }
14507 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
14508 if (!SWIG_IsOK(res2)) {
14509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14510 }
14511 if (!argp2) {
14512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14513 }
14514 arg2 = reinterpret_cast< wxBitmap * >(argp2);
14515 ecode3 = SWIG_AsVal_long(obj2, &val3);
14516 if (!SWIG_IsOK(ecode3)) {
14517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
14518 }
14519 arg3 = static_cast< long >(val3);
14520 {
14521 PyThreadState* __tstate = wxPyBeginAllowThreads();
14522 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
14523 wxPyEndAllowThreads(__tstate);
14524 if (PyErr_Occurred()) SWIG_fail;
14525 }
14526 resultobj = SWIG_Py_Void();
14527 {
14528 if (temp1)
14529 delete arg1;
14530 }
14531 return resultobj;
14532 fail:
14533 {
14534 if (temp1)
14535 delete arg1;
14536 }
14537 return NULL;
14538 }
14539
14540
14541 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14542 PyObject *resultobj = 0;
14543 wxString *arg1 = 0 ;
14544 PyObject *arg2 = (PyObject *) 0 ;
14545 bool temp1 = false ;
14546 PyObject * obj0 = 0 ;
14547 PyObject * obj1 = 0 ;
14548 char * kwnames[] = {
14549 (char *) "filename",(char *) "data", NULL
14550 };
14551
14552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14553 {
14554 arg1 = wxString_in_helper(obj0);
14555 if (arg1 == NULL) SWIG_fail;
14556 temp1 = true;
14557 }
14558 arg2 = obj1;
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 resultobj = SWIG_Py_Void();
14566 {
14567 if (temp1)
14568 delete arg1;
14569 }
14570 return resultobj;
14571 fail:
14572 {
14573 if (temp1)
14574 delete arg1;
14575 }
14576 return NULL;
14577 }
14578
14579
14580 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14581 PyObject *resultobj = 0;
14582 wxMemoryFSHandler *result = 0 ;
14583
14584 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14585 {
14586 PyThreadState* __tstate = wxPyBeginAllowThreads();
14587 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14592 return resultobj;
14593 fail:
14594 return NULL;
14595 }
14596
14597
14598 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14599 PyObject *resultobj = 0;
14600 wxString *arg1 = 0 ;
14601 bool temp1 = false ;
14602 PyObject * obj0 = 0 ;
14603 char * kwnames[] = {
14604 (char *) "filename", NULL
14605 };
14606
14607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14608 {
14609 arg1 = wxString_in_helper(obj0);
14610 if (arg1 == NULL) SWIG_fail;
14611 temp1 = true;
14612 }
14613 {
14614 PyThreadState* __tstate = wxPyBeginAllowThreads();
14615 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14616 wxPyEndAllowThreads(__tstate);
14617 if (PyErr_Occurred()) SWIG_fail;
14618 }
14619 resultobj = SWIG_Py_Void();
14620 {
14621 if (temp1)
14622 delete arg1;
14623 }
14624 return resultobj;
14625 fail:
14626 {
14627 if (temp1)
14628 delete arg1;
14629 }
14630 return NULL;
14631 }
14632
14633
14634 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14635 PyObject *resultobj = 0;
14636 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14637 wxString *arg2 = 0 ;
14638 bool result;
14639 void *argp1 = 0 ;
14640 int res1 = 0 ;
14641 bool temp2 = false ;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 char * kwnames[] = {
14645 (char *) "self",(char *) "location", NULL
14646 };
14647
14648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14650 if (!SWIG_IsOK(res1)) {
14651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14652 }
14653 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14654 {
14655 arg2 = wxString_in_helper(obj1);
14656 if (arg2 == NULL) SWIG_fail;
14657 temp2 = true;
14658 }
14659 {
14660 PyThreadState* __tstate = wxPyBeginAllowThreads();
14661 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 {
14666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14667 }
14668 {
14669 if (temp2)
14670 delete arg2;
14671 }
14672 return resultobj;
14673 fail:
14674 {
14675 if (temp2)
14676 delete arg2;
14677 }
14678 return NULL;
14679 }
14680
14681
14682 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14683 PyObject *resultobj = 0;
14684 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14685 wxFileSystem *arg2 = 0 ;
14686 wxString *arg3 = 0 ;
14687 wxFSFile *result = 0 ;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 void *argp2 = 0 ;
14691 int res2 = 0 ;
14692 bool temp3 = false ;
14693 PyObject * obj0 = 0 ;
14694 PyObject * obj1 = 0 ;
14695 PyObject * obj2 = 0 ;
14696 char * kwnames[] = {
14697 (char *) "self",(char *) "fs",(char *) "location", NULL
14698 };
14699
14700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14702 if (!SWIG_IsOK(res1)) {
14703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14704 }
14705 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14706 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14707 if (!SWIG_IsOK(res2)) {
14708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14709 }
14710 if (!argp2) {
14711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14712 }
14713 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14714 {
14715 arg3 = wxString_in_helper(obj2);
14716 if (arg3 == NULL) SWIG_fail;
14717 temp3 = true;
14718 }
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 {
14726 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14727 }
14728 {
14729 if (temp3)
14730 delete arg3;
14731 }
14732 return resultobj;
14733 fail:
14734 {
14735 if (temp3)
14736 delete arg3;
14737 }
14738 return NULL;
14739 }
14740
14741
14742 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14743 PyObject *resultobj = 0;
14744 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14745 wxString *arg2 = 0 ;
14746 int arg3 = (int) 0 ;
14747 wxString result;
14748 void *argp1 = 0 ;
14749 int res1 = 0 ;
14750 bool temp2 = false ;
14751 int val3 ;
14752 int ecode3 = 0 ;
14753 PyObject * obj0 = 0 ;
14754 PyObject * obj1 = 0 ;
14755 PyObject * obj2 = 0 ;
14756 char * kwnames[] = {
14757 (char *) "self",(char *) "spec",(char *) "flags", NULL
14758 };
14759
14760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14762 if (!SWIG_IsOK(res1)) {
14763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14764 }
14765 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14766 {
14767 arg2 = wxString_in_helper(obj1);
14768 if (arg2 == NULL) SWIG_fail;
14769 temp2 = true;
14770 }
14771 if (obj2) {
14772 ecode3 = SWIG_AsVal_int(obj2, &val3);
14773 if (!SWIG_IsOK(ecode3)) {
14774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14775 }
14776 arg3 = static_cast< int >(val3);
14777 }
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 {
14785 #if wxUSE_UNICODE
14786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14787 #else
14788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14789 #endif
14790 }
14791 {
14792 if (temp2)
14793 delete arg2;
14794 }
14795 return resultobj;
14796 fail:
14797 {
14798 if (temp2)
14799 delete arg2;
14800 }
14801 return NULL;
14802 }
14803
14804
14805 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14806 PyObject *resultobj = 0;
14807 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14808 wxString result;
14809 void *argp1 = 0 ;
14810 int res1 = 0 ;
14811 PyObject *swig_obj[1] ;
14812
14813 if (!args) SWIG_fail;
14814 swig_obj[0] = args;
14815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14816 if (!SWIG_IsOK(res1)) {
14817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14818 }
14819 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14820 {
14821 PyThreadState* __tstate = wxPyBeginAllowThreads();
14822 result = (arg1)->FindNext();
14823 wxPyEndAllowThreads(__tstate);
14824 if (PyErr_Occurred()) SWIG_fail;
14825 }
14826 {
14827 #if wxUSE_UNICODE
14828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14829 #else
14830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14831 #endif
14832 }
14833 return resultobj;
14834 fail:
14835 return NULL;
14836 }
14837
14838
14839 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14840 PyObject *obj;
14841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14842 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14843 return SWIG_Py_Void();
14844 }
14845
14846 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14847 return SWIG_Python_InitShadowInstance(args);
14848 }
14849
14850 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14851 PyObject *resultobj = 0;
14852 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14853 wxString result;
14854 void *argp1 = 0 ;
14855 int res1 = 0 ;
14856 PyObject *swig_obj[1] ;
14857
14858 if (!args) SWIG_fail;
14859 swig_obj[0] = args;
14860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14861 if (!SWIG_IsOK(res1)) {
14862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14863 }
14864 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14865 {
14866 PyThreadState* __tstate = wxPyBeginAllowThreads();
14867 result = (arg1)->GetName();
14868 wxPyEndAllowThreads(__tstate);
14869 if (PyErr_Occurred()) SWIG_fail;
14870 }
14871 {
14872 #if wxUSE_UNICODE
14873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14874 #else
14875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14876 #endif
14877 }
14878 return resultobj;
14879 fail:
14880 return NULL;
14881 }
14882
14883
14884 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14885 PyObject *resultobj = 0;
14886 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14887 wxString result;
14888 void *argp1 = 0 ;
14889 int res1 = 0 ;
14890 PyObject *swig_obj[1] ;
14891
14892 if (!args) SWIG_fail;
14893 swig_obj[0] = args;
14894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14895 if (!SWIG_IsOK(res1)) {
14896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14897 }
14898 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14899 {
14900 PyThreadState* __tstate = wxPyBeginAllowThreads();
14901 result = (arg1)->GetExtension();
14902 wxPyEndAllowThreads(__tstate);
14903 if (PyErr_Occurred()) SWIG_fail;
14904 }
14905 {
14906 #if wxUSE_UNICODE
14907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14908 #else
14909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14910 #endif
14911 }
14912 return resultobj;
14913 fail:
14914 return NULL;
14915 }
14916
14917
14918 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14919 PyObject *resultobj = 0;
14920 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14921 long result;
14922 void *argp1 = 0 ;
14923 int res1 = 0 ;
14924 PyObject *swig_obj[1] ;
14925
14926 if (!args) SWIG_fail;
14927 swig_obj[0] = args;
14928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14929 if (!SWIG_IsOK(res1)) {
14930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14931 }
14932 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 result = (long)(arg1)->GetType();
14936 wxPyEndAllowThreads(__tstate);
14937 if (PyErr_Occurred()) SWIG_fail;
14938 }
14939 resultobj = SWIG_From_long(static_cast< long >(result));
14940 return resultobj;
14941 fail:
14942 return NULL;
14943 }
14944
14945
14946 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14947 PyObject *resultobj = 0;
14948 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14949 wxString result;
14950 void *argp1 = 0 ;
14951 int res1 = 0 ;
14952 PyObject *swig_obj[1] ;
14953
14954 if (!args) SWIG_fail;
14955 swig_obj[0] = args;
14956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14957 if (!SWIG_IsOK(res1)) {
14958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14959 }
14960 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14961 {
14962 PyThreadState* __tstate = wxPyBeginAllowThreads();
14963 result = (arg1)->GetMimeType();
14964 wxPyEndAllowThreads(__tstate);
14965 if (PyErr_Occurred()) SWIG_fail;
14966 }
14967 {
14968 #if wxUSE_UNICODE
14969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14970 #else
14971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14972 #endif
14973 }
14974 return resultobj;
14975 fail:
14976 return NULL;
14977 }
14978
14979
14980 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14981 PyObject *resultobj = 0;
14982 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14983 wxString *arg2 = 0 ;
14984 bool result;
14985 void *argp1 = 0 ;
14986 int res1 = 0 ;
14987 bool temp2 = false ;
14988 PyObject * obj0 = 0 ;
14989 PyObject * obj1 = 0 ;
14990 char * kwnames[] = {
14991 (char *) "self",(char *) "name", NULL
14992 };
14993
14994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14996 if (!SWIG_IsOK(res1)) {
14997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14998 }
14999 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15000 {
15001 arg2 = wxString_in_helper(obj1);
15002 if (arg2 == NULL) SWIG_fail;
15003 temp2 = true;
15004 }
15005 {
15006 PyThreadState* __tstate = wxPyBeginAllowThreads();
15007 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
15008 wxPyEndAllowThreads(__tstate);
15009 if (PyErr_Occurred()) SWIG_fail;
15010 }
15011 {
15012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15013 }
15014 {
15015 if (temp2)
15016 delete arg2;
15017 }
15018 return resultobj;
15019 fail:
15020 {
15021 if (temp2)
15022 delete arg2;
15023 }
15024 return NULL;
15025 }
15026
15027
15028 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15029 PyObject *resultobj = 0;
15030 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15031 wxInputStream *arg2 = 0 ;
15032 bool result;
15033 void *argp1 = 0 ;
15034 int res1 = 0 ;
15035 wxPyInputStream *temp2 ;
15036 bool created2 ;
15037 PyObject * obj0 = 0 ;
15038 PyObject * obj1 = 0 ;
15039 char * kwnames[] = {
15040 (char *) "self",(char *) "stream", NULL
15041 };
15042
15043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
15044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15045 if (!SWIG_IsOK(res1)) {
15046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15047 }
15048 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15049 {
15050 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15051 arg2 = temp2->m_wxis;
15052 created2 = false;
15053 } else {
15054 PyErr_Clear(); // clear the failure of the wxPyConvert above
15055 arg2 = wxPyCBInputStream_create(obj1, false);
15056 if (arg2 == NULL) {
15057 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15058 SWIG_fail;
15059 }
15060 created2 = true;
15061 }
15062 }
15063 {
15064 PyThreadState* __tstate = wxPyBeginAllowThreads();
15065 result = (bool)(arg1)->CanRead(*arg2);
15066 wxPyEndAllowThreads(__tstate);
15067 if (PyErr_Occurred()) SWIG_fail;
15068 }
15069 {
15070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15071 }
15072 {
15073 if (created2) delete arg2;
15074 }
15075 return resultobj;
15076 fail:
15077 {
15078 if (created2) delete arg2;
15079 }
15080 return NULL;
15081 }
15082
15083
15084 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15085 PyObject *resultobj = 0;
15086 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15087 wxString *arg2 = 0 ;
15088 void *argp1 = 0 ;
15089 int res1 = 0 ;
15090 bool temp2 = false ;
15091 PyObject * obj0 = 0 ;
15092 PyObject * obj1 = 0 ;
15093 char * kwnames[] = {
15094 (char *) "self",(char *) "name", NULL
15095 };
15096
15097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
15098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15099 if (!SWIG_IsOK(res1)) {
15100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15101 }
15102 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15103 {
15104 arg2 = wxString_in_helper(obj1);
15105 if (arg2 == NULL) SWIG_fail;
15106 temp2 = true;
15107 }
15108 {
15109 PyThreadState* __tstate = wxPyBeginAllowThreads();
15110 (arg1)->SetName((wxString const &)*arg2);
15111 wxPyEndAllowThreads(__tstate);
15112 if (PyErr_Occurred()) SWIG_fail;
15113 }
15114 resultobj = SWIG_Py_Void();
15115 {
15116 if (temp2)
15117 delete arg2;
15118 }
15119 return resultobj;
15120 fail:
15121 {
15122 if (temp2)
15123 delete arg2;
15124 }
15125 return NULL;
15126 }
15127
15128
15129 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15130 PyObject *resultobj = 0;
15131 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15132 wxString *arg2 = 0 ;
15133 void *argp1 = 0 ;
15134 int res1 = 0 ;
15135 bool temp2 = false ;
15136 PyObject * obj0 = 0 ;
15137 PyObject * obj1 = 0 ;
15138 char * kwnames[] = {
15139 (char *) "self",(char *) "extension", NULL
15140 };
15141
15142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
15143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15144 if (!SWIG_IsOK(res1)) {
15145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15146 }
15147 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15148 {
15149 arg2 = wxString_in_helper(obj1);
15150 if (arg2 == NULL) SWIG_fail;
15151 temp2 = true;
15152 }
15153 {
15154 PyThreadState* __tstate = wxPyBeginAllowThreads();
15155 (arg1)->SetExtension((wxString const &)*arg2);
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 resultobj = SWIG_Py_Void();
15160 {
15161 if (temp2)
15162 delete arg2;
15163 }
15164 return resultobj;
15165 fail:
15166 {
15167 if (temp2)
15168 delete arg2;
15169 }
15170 return NULL;
15171 }
15172
15173
15174 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15175 PyObject *resultobj = 0;
15176 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15177 long arg2 ;
15178 void *argp1 = 0 ;
15179 int res1 = 0 ;
15180 long val2 ;
15181 int ecode2 = 0 ;
15182 PyObject * obj0 = 0 ;
15183 PyObject * obj1 = 0 ;
15184 char * kwnames[] = {
15185 (char *) "self",(char *) "type", NULL
15186 };
15187
15188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
15189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15190 if (!SWIG_IsOK(res1)) {
15191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15192 }
15193 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15194 ecode2 = SWIG_AsVal_long(obj1, &val2);
15195 if (!SWIG_IsOK(ecode2)) {
15196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
15197 }
15198 arg2 = static_cast< long >(val2);
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 (arg1)->SetType(arg2);
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 resultobj = SWIG_Py_Void();
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15213 PyObject *resultobj = 0;
15214 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15215 wxString *arg2 = 0 ;
15216 void *argp1 = 0 ;
15217 int res1 = 0 ;
15218 bool temp2 = false ;
15219 PyObject * obj0 = 0 ;
15220 PyObject * obj1 = 0 ;
15221 char * kwnames[] = {
15222 (char *) "self",(char *) "mimetype", NULL
15223 };
15224
15225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
15226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15227 if (!SWIG_IsOK(res1)) {
15228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15229 }
15230 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15231 {
15232 arg2 = wxString_in_helper(obj1);
15233 if (arg2 == NULL) SWIG_fail;
15234 temp2 = true;
15235 }
15236 {
15237 PyThreadState* __tstate = wxPyBeginAllowThreads();
15238 (arg1)->SetMimeType((wxString const &)*arg2);
15239 wxPyEndAllowThreads(__tstate);
15240 if (PyErr_Occurred()) SWIG_fail;
15241 }
15242 resultobj = SWIG_Py_Void();
15243 {
15244 if (temp2)
15245 delete arg2;
15246 }
15247 return resultobj;
15248 fail:
15249 {
15250 if (temp2)
15251 delete arg2;
15252 }
15253 return NULL;
15254 }
15255
15256
15257 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15258 PyObject *obj;
15259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15260 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
15261 return SWIG_Py_Void();
15262 }
15263
15264 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15265 PyObject *resultobj = 0;
15266 wxPyImageHandler *result = 0 ;
15267
15268 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
15269 {
15270 PyThreadState* __tstate = wxPyBeginAllowThreads();
15271 result = (wxPyImageHandler *)new wxPyImageHandler();
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
15276 return resultobj;
15277 fail:
15278 return NULL;
15279 }
15280
15281
15282 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15283 PyObject *resultobj = 0;
15284 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
15285 PyObject *arg2 = (PyObject *) 0 ;
15286 void *argp1 = 0 ;
15287 int res1 = 0 ;
15288 PyObject * obj0 = 0 ;
15289 PyObject * obj1 = 0 ;
15290 char * kwnames[] = {
15291 (char *) "self",(char *) "self", NULL
15292 };
15293
15294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
15295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
15296 if (!SWIG_IsOK(res1)) {
15297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
15298 }
15299 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
15300 arg2 = obj1;
15301 {
15302 PyThreadState* __tstate = wxPyBeginAllowThreads();
15303 (arg1)->_SetSelf(arg2);
15304 wxPyEndAllowThreads(__tstate);
15305 if (PyErr_Occurred()) SWIG_fail;
15306 }
15307 resultobj = SWIG_Py_Void();
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15315 PyObject *obj;
15316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15317 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
15318 return SWIG_Py_Void();
15319 }
15320
15321 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15322 return SWIG_Python_InitShadowInstance(args);
15323 }
15324
15325 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15326 PyObject *resultobj = 0;
15327 wxImageHistogram *result = 0 ;
15328
15329 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
15330 {
15331 PyThreadState* __tstate = wxPyBeginAllowThreads();
15332 result = (wxImageHistogram *)new wxImageHistogram();
15333 wxPyEndAllowThreads(__tstate);
15334 if (PyErr_Occurred()) SWIG_fail;
15335 }
15336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
15337 return resultobj;
15338 fail:
15339 return NULL;
15340 }
15341
15342
15343 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15344 PyObject *resultobj = 0;
15345 byte arg1 ;
15346 byte arg2 ;
15347 byte arg3 ;
15348 unsigned long result;
15349 unsigned char val1 ;
15350 int ecode1 = 0 ;
15351 unsigned char val2 ;
15352 int ecode2 = 0 ;
15353 unsigned char val3 ;
15354 int ecode3 = 0 ;
15355 PyObject * obj0 = 0 ;
15356 PyObject * obj1 = 0 ;
15357 PyObject * obj2 = 0 ;
15358 char * kwnames[] = {
15359 (char *) "r",(char *) "g",(char *) "b", NULL
15360 };
15361
15362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15363 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15364 if (!SWIG_IsOK(ecode1)) {
15365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
15366 }
15367 arg1 = static_cast< byte >(val1);
15368 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15369 if (!SWIG_IsOK(ecode2)) {
15370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
15371 }
15372 arg2 = static_cast< byte >(val2);
15373 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15374 if (!SWIG_IsOK(ecode3)) {
15375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
15376 }
15377 arg3 = static_cast< byte >(val3);
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
15381 wxPyEndAllowThreads(__tstate);
15382 if (PyErr_Occurred()) SWIG_fail;
15383 }
15384 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15392 PyObject *resultobj = 0;
15393 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15394 byte *arg2 = (byte *) 0 ;
15395 byte *arg3 = (byte *) 0 ;
15396 byte *arg4 = (byte *) 0 ;
15397 byte arg5 = (byte) 1 ;
15398 byte arg6 = (byte) 0 ;
15399 byte arg7 = (byte) 0 ;
15400 bool result;
15401 void *argp1 = 0 ;
15402 int res1 = 0 ;
15403 byte temp2 ;
15404 int res2 = SWIG_TMPOBJ ;
15405 byte temp3 ;
15406 int res3 = SWIG_TMPOBJ ;
15407 byte temp4 ;
15408 int res4 = SWIG_TMPOBJ ;
15409 unsigned char val5 ;
15410 int ecode5 = 0 ;
15411 unsigned char val6 ;
15412 int ecode6 = 0 ;
15413 unsigned char val7 ;
15414 int ecode7 = 0 ;
15415 PyObject * obj0 = 0 ;
15416 PyObject * obj1 = 0 ;
15417 PyObject * obj2 = 0 ;
15418 PyObject * obj3 = 0 ;
15419 char * kwnames[] = {
15420 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
15421 };
15422
15423 arg2 = &temp2;
15424 arg3 = &temp3;
15425 arg4 = &temp4;
15426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15428 if (!SWIG_IsOK(res1)) {
15429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
15430 }
15431 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15432 if (obj1) {
15433 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
15434 if (!SWIG_IsOK(ecode5)) {
15435 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
15436 }
15437 arg5 = static_cast< byte >(val5);
15438 }
15439 if (obj2) {
15440 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
15441 if (!SWIG_IsOK(ecode6)) {
15442 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
15443 }
15444 arg6 = static_cast< byte >(val6);
15445 }
15446 if (obj3) {
15447 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
15448 if (!SWIG_IsOK(ecode7)) {
15449 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
15450 }
15451 arg7 = static_cast< byte >(val7);
15452 }
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
15456 wxPyEndAllowThreads(__tstate);
15457 if (PyErr_Occurred()) SWIG_fail;
15458 }
15459 {
15460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15461 }
15462 if (SWIG_IsTmpObj(res2)) {
15463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15464 } else {
15465 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15467 }
15468 if (SWIG_IsTmpObj(res3)) {
15469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15470 } else {
15471 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15473 }
15474 if (SWIG_IsTmpObj(res4)) {
15475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15476 } else {
15477 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15479 }
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15489 unsigned long arg2 ;
15490 unsigned long result;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 unsigned long val2 ;
15494 int ecode2 = 0 ;
15495 PyObject * obj0 = 0 ;
15496 PyObject * obj1 = 0 ;
15497 char * kwnames[] = {
15498 (char *) "self",(char *) "key", NULL
15499 };
15500
15501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
15502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15503 if (!SWIG_IsOK(res1)) {
15504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15505 }
15506 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15507 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
15508 if (!SWIG_IsOK(ecode2)) {
15509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
15510 }
15511 arg2 = static_cast< unsigned long >(val2);
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15526 PyObject *resultobj = 0;
15527 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15528 byte arg2 ;
15529 byte arg3 ;
15530 byte arg4 ;
15531 unsigned long result;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 unsigned char val2 ;
15535 int ecode2 = 0 ;
15536 unsigned char val3 ;
15537 int ecode3 = 0 ;
15538 unsigned char val4 ;
15539 int ecode4 = 0 ;
15540 PyObject * obj0 = 0 ;
15541 PyObject * obj1 = 0 ;
15542 PyObject * obj2 = 0 ;
15543 PyObject * obj3 = 0 ;
15544 char * kwnames[] = {
15545 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15546 };
15547
15548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15550 if (!SWIG_IsOK(res1)) {
15551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15552 }
15553 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15554 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15555 if (!SWIG_IsOK(ecode2)) {
15556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15557 }
15558 arg2 = static_cast< byte >(val2);
15559 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15560 if (!SWIG_IsOK(ecode3)) {
15561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15562 }
15563 arg3 = static_cast< byte >(val3);
15564 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15565 if (!SWIG_IsOK(ecode4)) {
15566 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15567 }
15568 arg4 = static_cast< byte >(val4);
15569 {
15570 PyThreadState* __tstate = wxPyBeginAllowThreads();
15571 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15572 wxPyEndAllowThreads(__tstate);
15573 if (PyErr_Occurred()) SWIG_fail;
15574 }
15575 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15576 return resultobj;
15577 fail:
15578 return NULL;
15579 }
15580
15581
15582 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15583 PyObject *resultobj = 0;
15584 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15585 wxColour *arg2 = 0 ;
15586 unsigned long result;
15587 void *argp1 = 0 ;
15588 int res1 = 0 ;
15589 wxColour temp2 ;
15590 PyObject * obj0 = 0 ;
15591 PyObject * obj1 = 0 ;
15592 char * kwnames[] = {
15593 (char *) "self",(char *) "colour", NULL
15594 };
15595
15596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15598 if (!SWIG_IsOK(res1)) {
15599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15600 }
15601 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15602 {
15603 arg2 = &temp2;
15604 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15605 }
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15613 return resultobj;
15614 fail:
15615 return NULL;
15616 }
15617
15618
15619 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15620 PyObject *obj;
15621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15622 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15623 return SWIG_Py_Void();
15624 }
15625
15626 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15627 return SWIG_Python_InitShadowInstance(args);
15628 }
15629
15630 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15631 PyObject *resultobj = 0;
15632 byte arg1 = (byte) 0 ;
15633 byte arg2 = (byte) 0 ;
15634 byte arg3 = (byte) 0 ;
15635 wxImage_RGBValue *result = 0 ;
15636 unsigned char val1 ;
15637 int ecode1 = 0 ;
15638 unsigned char val2 ;
15639 int ecode2 = 0 ;
15640 unsigned char val3 ;
15641 int ecode3 = 0 ;
15642 PyObject * obj0 = 0 ;
15643 PyObject * obj1 = 0 ;
15644 PyObject * obj2 = 0 ;
15645 char * kwnames[] = {
15646 (char *) "r",(char *) "g",(char *) "b", NULL
15647 };
15648
15649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15650 if (obj0) {
15651 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15652 if (!SWIG_IsOK(ecode1)) {
15653 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15654 }
15655 arg1 = static_cast< byte >(val1);
15656 }
15657 if (obj1) {
15658 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15659 if (!SWIG_IsOK(ecode2)) {
15660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15661 }
15662 arg2 = static_cast< byte >(val2);
15663 }
15664 if (obj2) {
15665 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15666 if (!SWIG_IsOK(ecode3)) {
15667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15668 }
15669 arg3 = static_cast< byte >(val3);
15670 }
15671 {
15672 PyThreadState* __tstate = wxPyBeginAllowThreads();
15673 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15674 wxPyEndAllowThreads(__tstate);
15675 if (PyErr_Occurred()) SWIG_fail;
15676 }
15677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15678 return resultobj;
15679 fail:
15680 return NULL;
15681 }
15682
15683
15684 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15685 PyObject *resultobj = 0;
15686 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15687 byte arg2 ;
15688 void *argp1 = 0 ;
15689 int res1 = 0 ;
15690 unsigned char val2 ;
15691 int ecode2 = 0 ;
15692 PyObject *swig_obj[2] ;
15693
15694 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15696 if (!SWIG_IsOK(res1)) {
15697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15698 }
15699 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15700 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15701 if (!SWIG_IsOK(ecode2)) {
15702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15703 }
15704 arg2 = static_cast< byte >(val2);
15705 if (arg1) (arg1)->red = arg2;
15706
15707 resultobj = SWIG_Py_Void();
15708 return resultobj;
15709 fail:
15710 return NULL;
15711 }
15712
15713
15714 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15715 PyObject *resultobj = 0;
15716 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15717 byte result;
15718 void *argp1 = 0 ;
15719 int res1 = 0 ;
15720 PyObject *swig_obj[1] ;
15721
15722 if (!args) SWIG_fail;
15723 swig_obj[0] = args;
15724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15725 if (!SWIG_IsOK(res1)) {
15726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15727 }
15728 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15729 result = (byte) ((arg1)->red);
15730 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15740 byte arg2 ;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 unsigned char val2 ;
15744 int ecode2 = 0 ;
15745 PyObject *swig_obj[2] ;
15746
15747 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15751 }
15752 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15753 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15754 if (!SWIG_IsOK(ecode2)) {
15755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15756 }
15757 arg2 = static_cast< byte >(val2);
15758 if (arg1) (arg1)->green = arg2;
15759
15760 resultobj = SWIG_Py_Void();
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15768 PyObject *resultobj = 0;
15769 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15770 byte result;
15771 void *argp1 = 0 ;
15772 int res1 = 0 ;
15773 PyObject *swig_obj[1] ;
15774
15775 if (!args) SWIG_fail;
15776 swig_obj[0] = args;
15777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15778 if (!SWIG_IsOK(res1)) {
15779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15780 }
15781 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15782 result = (byte) ((arg1)->green);
15783 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15784 return resultobj;
15785 fail:
15786 return NULL;
15787 }
15788
15789
15790 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15791 PyObject *resultobj = 0;
15792 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15793 byte arg2 ;
15794 void *argp1 = 0 ;
15795 int res1 = 0 ;
15796 unsigned char val2 ;
15797 int ecode2 = 0 ;
15798 PyObject *swig_obj[2] ;
15799
15800 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15802 if (!SWIG_IsOK(res1)) {
15803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15804 }
15805 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15806 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15807 if (!SWIG_IsOK(ecode2)) {
15808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15809 }
15810 arg2 = static_cast< byte >(val2);
15811 if (arg1) (arg1)->blue = arg2;
15812
15813 resultobj = SWIG_Py_Void();
15814 return resultobj;
15815 fail:
15816 return NULL;
15817 }
15818
15819
15820 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15821 PyObject *resultobj = 0;
15822 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15823 byte result;
15824 void *argp1 = 0 ;
15825 int res1 = 0 ;
15826 PyObject *swig_obj[1] ;
15827
15828 if (!args) SWIG_fail;
15829 swig_obj[0] = args;
15830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15831 if (!SWIG_IsOK(res1)) {
15832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15833 }
15834 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15835 result = (byte) ((arg1)->blue);
15836 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15844 PyObject *obj;
15845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15846 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15847 return SWIG_Py_Void();
15848 }
15849
15850 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15851 return SWIG_Python_InitShadowInstance(args);
15852 }
15853
15854 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15855 PyObject *resultobj = 0;
15856 double arg1 = (double) 0.0 ;
15857 double arg2 = (double) 0.0 ;
15858 double arg3 = (double) 0.0 ;
15859 wxImage_HSVValue *result = 0 ;
15860 double val1 ;
15861 int ecode1 = 0 ;
15862 double val2 ;
15863 int ecode2 = 0 ;
15864 double val3 ;
15865 int ecode3 = 0 ;
15866 PyObject * obj0 = 0 ;
15867 PyObject * obj1 = 0 ;
15868 PyObject * obj2 = 0 ;
15869 char * kwnames[] = {
15870 (char *) "h",(char *) "s",(char *) "v", NULL
15871 };
15872
15873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15874 if (obj0) {
15875 ecode1 = SWIG_AsVal_double(obj0, &val1);
15876 if (!SWIG_IsOK(ecode1)) {
15877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15878 }
15879 arg1 = static_cast< double >(val1);
15880 }
15881 if (obj1) {
15882 ecode2 = SWIG_AsVal_double(obj1, &val2);
15883 if (!SWIG_IsOK(ecode2)) {
15884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15885 }
15886 arg2 = static_cast< double >(val2);
15887 }
15888 if (obj2) {
15889 ecode3 = SWIG_AsVal_double(obj2, &val3);
15890 if (!SWIG_IsOK(ecode3)) {
15891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15892 }
15893 arg3 = static_cast< double >(val3);
15894 }
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15898 wxPyEndAllowThreads(__tstate);
15899 if (PyErr_Occurred()) SWIG_fail;
15900 }
15901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15902 return resultobj;
15903 fail:
15904 return NULL;
15905 }
15906
15907
15908 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15909 PyObject *resultobj = 0;
15910 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15911 double arg2 ;
15912 void *argp1 = 0 ;
15913 int res1 = 0 ;
15914 double val2 ;
15915 int ecode2 = 0 ;
15916 PyObject *swig_obj[2] ;
15917
15918 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15920 if (!SWIG_IsOK(res1)) {
15921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15922 }
15923 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15924 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15925 if (!SWIG_IsOK(ecode2)) {
15926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15927 }
15928 arg2 = static_cast< double >(val2);
15929 if (arg1) (arg1)->hue = arg2;
15930
15931 resultobj = SWIG_Py_Void();
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15939 PyObject *resultobj = 0;
15940 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15941 double result;
15942 void *argp1 = 0 ;
15943 int res1 = 0 ;
15944 PyObject *swig_obj[1] ;
15945
15946 if (!args) SWIG_fail;
15947 swig_obj[0] = args;
15948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15949 if (!SWIG_IsOK(res1)) {
15950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15951 }
15952 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15953 result = (double) ((arg1)->hue);
15954 resultobj = SWIG_From_double(static_cast< double >(result));
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15962 PyObject *resultobj = 0;
15963 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15964 double arg2 ;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 double val2 ;
15968 int ecode2 = 0 ;
15969 PyObject *swig_obj[2] ;
15970
15971 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15973 if (!SWIG_IsOK(res1)) {
15974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15975 }
15976 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15977 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15978 if (!SWIG_IsOK(ecode2)) {
15979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15980 }
15981 arg2 = static_cast< double >(val2);
15982 if (arg1) (arg1)->saturation = arg2;
15983
15984 resultobj = SWIG_Py_Void();
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15992 PyObject *resultobj = 0;
15993 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15994 double result;
15995 void *argp1 = 0 ;
15996 int res1 = 0 ;
15997 PyObject *swig_obj[1] ;
15998
15999 if (!args) SWIG_fail;
16000 swig_obj[0] = args;
16001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16002 if (!SWIG_IsOK(res1)) {
16003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16004 }
16005 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16006 result = (double) ((arg1)->saturation);
16007 resultobj = SWIG_From_double(static_cast< double >(result));
16008 return resultobj;
16009 fail:
16010 return NULL;
16011 }
16012
16013
16014 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16015 PyObject *resultobj = 0;
16016 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16017 double arg2 ;
16018 void *argp1 = 0 ;
16019 int res1 = 0 ;
16020 double val2 ;
16021 int ecode2 = 0 ;
16022 PyObject *swig_obj[2] ;
16023
16024 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
16025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16026 if (!SWIG_IsOK(res1)) {
16027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16028 }
16029 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16030 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
16031 if (!SWIG_IsOK(ecode2)) {
16032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
16033 }
16034 arg2 = static_cast< double >(val2);
16035 if (arg1) (arg1)->value = arg2;
16036
16037 resultobj = SWIG_Py_Void();
16038 return resultobj;
16039 fail:
16040 return NULL;
16041 }
16042
16043
16044 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16045 PyObject *resultobj = 0;
16046 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16047 double result;
16048 void *argp1 = 0 ;
16049 int res1 = 0 ;
16050 PyObject *swig_obj[1] ;
16051
16052 if (!args) SWIG_fail;
16053 swig_obj[0] = args;
16054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16055 if (!SWIG_IsOK(res1)) {
16056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16057 }
16058 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16059 result = (double) ((arg1)->value);
16060 resultobj = SWIG_From_double(static_cast< double >(result));
16061 return resultobj;
16062 fail:
16063 return NULL;
16064 }
16065
16066
16067 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16068 PyObject *obj;
16069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16070 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
16071 return SWIG_Py_Void();
16072 }
16073
16074 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16075 return SWIG_Python_InitShadowInstance(args);
16076 }
16077
16078 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16079 PyObject *resultobj = 0;
16080 wxString *arg1 = 0 ;
16081 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16082 int arg3 = (int) -1 ;
16083 wxImage *result = 0 ;
16084 bool temp1 = false ;
16085 long val2 ;
16086 int ecode2 = 0 ;
16087 int val3 ;
16088 int ecode3 = 0 ;
16089 PyObject * obj0 = 0 ;
16090 PyObject * obj1 = 0 ;
16091 PyObject * obj2 = 0 ;
16092 char * kwnames[] = {
16093 (char *) "name",(char *) "type",(char *) "index", NULL
16094 };
16095
16096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16097 {
16098 arg1 = wxString_in_helper(obj0);
16099 if (arg1 == NULL) SWIG_fail;
16100 temp1 = true;
16101 }
16102 if (obj1) {
16103 ecode2 = SWIG_AsVal_long(obj1, &val2);
16104 if (!SWIG_IsOK(ecode2)) {
16105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
16106 }
16107 arg2 = static_cast< long >(val2);
16108 }
16109 if (obj2) {
16110 ecode3 = SWIG_AsVal_int(obj2, &val3);
16111 if (!SWIG_IsOK(ecode3)) {
16112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
16113 }
16114 arg3 = static_cast< int >(val3);
16115 }
16116 {
16117 PyThreadState* __tstate = wxPyBeginAllowThreads();
16118 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
16119 wxPyEndAllowThreads(__tstate);
16120 if (PyErr_Occurred()) SWIG_fail;
16121 }
16122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
16123 {
16124 if (temp1)
16125 delete arg1;
16126 }
16127 return resultobj;
16128 fail:
16129 {
16130 if (temp1)
16131 delete arg1;
16132 }
16133 return NULL;
16134 }
16135
16136
16137 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16138 PyObject *resultobj = 0;
16139 wxImage *arg1 = (wxImage *) 0 ;
16140 void *argp1 = 0 ;
16141 int res1 = 0 ;
16142 PyObject *swig_obj[1] ;
16143
16144 if (!args) SWIG_fail;
16145 swig_obj[0] = args;
16146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
16147 if (!SWIG_IsOK(res1)) {
16148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
16149 }
16150 arg1 = reinterpret_cast< wxImage * >(argp1);
16151 {
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 delete arg1;
16154
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 resultobj = SWIG_Py_Void();
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16166 PyObject *resultobj = 0;
16167 wxString *arg1 = 0 ;
16168 wxString *arg2 = 0 ;
16169 int arg3 = (int) -1 ;
16170 wxImage *result = 0 ;
16171 bool temp1 = false ;
16172 bool temp2 = false ;
16173 int val3 ;
16174 int ecode3 = 0 ;
16175 PyObject * obj0 = 0 ;
16176 PyObject * obj1 = 0 ;
16177 PyObject * obj2 = 0 ;
16178 char * kwnames[] = {
16179 (char *) "name",(char *) "mimetype",(char *) "index", NULL
16180 };
16181
16182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16183 {
16184 arg1 = wxString_in_helper(obj0);
16185 if (arg1 == NULL) SWIG_fail;
16186 temp1 = true;
16187 }
16188 {
16189 arg2 = wxString_in_helper(obj1);
16190 if (arg2 == NULL) SWIG_fail;
16191 temp2 = true;
16192 }
16193 if (obj2) {
16194 ecode3 = SWIG_AsVal_int(obj2, &val3);
16195 if (!SWIG_IsOK(ecode3)) {
16196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
16197 }
16198 arg3 = static_cast< int >(val3);
16199 }
16200 {
16201 PyThreadState* __tstate = wxPyBeginAllowThreads();
16202 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16207 {
16208 if (temp1)
16209 delete arg1;
16210 }
16211 {
16212 if (temp2)
16213 delete arg2;
16214 }
16215 return resultobj;
16216 fail:
16217 {
16218 if (temp1)
16219 delete arg1;
16220 }
16221 {
16222 if (temp2)
16223 delete arg2;
16224 }
16225 return NULL;
16226 }
16227
16228
16229 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16230 PyObject *resultobj = 0;
16231 wxInputStream *arg1 = 0 ;
16232 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16233 int arg3 = (int) -1 ;
16234 wxImage *result = 0 ;
16235 wxPyInputStream *temp1 ;
16236 bool created1 ;
16237 long val2 ;
16238 int ecode2 = 0 ;
16239 int val3 ;
16240 int ecode3 = 0 ;
16241 PyObject * obj0 = 0 ;
16242 PyObject * obj1 = 0 ;
16243 PyObject * obj2 = 0 ;
16244 char * kwnames[] = {
16245 (char *) "stream",(char *) "type",(char *) "index", NULL
16246 };
16247
16248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16249 {
16250 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16251 arg1 = temp1->m_wxis;
16252 created1 = false;
16253 } else {
16254 PyErr_Clear(); // clear the failure of the wxPyConvert above
16255 arg1 = wxPyCBInputStream_create(obj0, false);
16256 if (arg1 == NULL) {
16257 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16258 SWIG_fail;
16259 }
16260 created1 = true;
16261 }
16262 }
16263 if (obj1) {
16264 ecode2 = SWIG_AsVal_long(obj1, &val2);
16265 if (!SWIG_IsOK(ecode2)) {
16266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
16267 }
16268 arg2 = static_cast< long >(val2);
16269 }
16270 if (obj2) {
16271 ecode3 = SWIG_AsVal_int(obj2, &val3);
16272 if (!SWIG_IsOK(ecode3)) {
16273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
16274 }
16275 arg3 = static_cast< int >(val3);
16276 }
16277 {
16278 PyThreadState* __tstate = wxPyBeginAllowThreads();
16279 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
16280 wxPyEndAllowThreads(__tstate);
16281 if (PyErr_Occurred()) SWIG_fail;
16282 }
16283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16284 {
16285 if (created1) delete arg1;
16286 }
16287 return resultobj;
16288 fail:
16289 {
16290 if (created1) delete arg1;
16291 }
16292 return NULL;
16293 }
16294
16295
16296 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16297 PyObject *resultobj = 0;
16298 wxInputStream *arg1 = 0 ;
16299 wxString *arg2 = 0 ;
16300 int arg3 = (int) -1 ;
16301 wxImage *result = 0 ;
16302 wxPyInputStream *temp1 ;
16303 bool created1 ;
16304 bool temp2 = false ;
16305 int val3 ;
16306 int ecode3 = 0 ;
16307 PyObject * obj0 = 0 ;
16308 PyObject * obj1 = 0 ;
16309 PyObject * obj2 = 0 ;
16310 char * kwnames[] = {
16311 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
16312 };
16313
16314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16315 {
16316 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16317 arg1 = temp1->m_wxis;
16318 created1 = false;
16319 } else {
16320 PyErr_Clear(); // clear the failure of the wxPyConvert above
16321 arg1 = wxPyCBInputStream_create(obj0, false);
16322 if (arg1 == NULL) {
16323 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16324 SWIG_fail;
16325 }
16326 created1 = true;
16327 }
16328 }
16329 {
16330 arg2 = wxString_in_helper(obj1);
16331 if (arg2 == NULL) SWIG_fail;
16332 temp2 = true;
16333 }
16334 if (obj2) {
16335 ecode3 = SWIG_AsVal_int(obj2, &val3);
16336 if (!SWIG_IsOK(ecode3)) {
16337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
16338 }
16339 arg3 = static_cast< int >(val3);
16340 }
16341 {
16342 PyThreadState* __tstate = wxPyBeginAllowThreads();
16343 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
16344 wxPyEndAllowThreads(__tstate);
16345 if (PyErr_Occurred()) SWIG_fail;
16346 }
16347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16348 {
16349 if (created1) delete arg1;
16350 }
16351 {
16352 if (temp2)
16353 delete arg2;
16354 }
16355 return resultobj;
16356 fail:
16357 {
16358 if (created1) delete arg1;
16359 }
16360 {
16361 if (temp2)
16362 delete arg2;
16363 }
16364 return NULL;
16365 }
16366
16367
16368 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16369 PyObject *resultobj = 0;
16370 int arg1 = (int) 0 ;
16371 int arg2 = (int) 0 ;
16372 bool arg3 = (bool) true ;
16373 wxImage *result = 0 ;
16374 int val1 ;
16375 int ecode1 = 0 ;
16376 int val2 ;
16377 int ecode2 = 0 ;
16378 bool val3 ;
16379 int ecode3 = 0 ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 PyObject * obj2 = 0 ;
16383 char * kwnames[] = {
16384 (char *) "width",(char *) "height",(char *) "clear", NULL
16385 };
16386
16387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16388 if (obj0) {
16389 ecode1 = SWIG_AsVal_int(obj0, &val1);
16390 if (!SWIG_IsOK(ecode1)) {
16391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
16392 }
16393 arg1 = static_cast< int >(val1);
16394 }
16395 if (obj1) {
16396 ecode2 = SWIG_AsVal_int(obj1, &val2);
16397 if (!SWIG_IsOK(ecode2)) {
16398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
16399 }
16400 arg2 = static_cast< int >(val2);
16401 }
16402 if (obj2) {
16403 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16404 if (!SWIG_IsOK(ecode3)) {
16405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
16406 }
16407 arg3 = static_cast< bool >(val3);
16408 }
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
16412 wxPyEndAllowThreads(__tstate);
16413 if (PyErr_Occurred()) SWIG_fail;
16414 }
16415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16416 return resultobj;
16417 fail:
16418 return NULL;
16419 }
16420
16421
16422 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16423 PyObject *resultobj = 0;
16424 wxBitmap *arg1 = 0 ;
16425 wxImage *result = 0 ;
16426 void *argp1 = 0 ;
16427 int res1 = 0 ;
16428 PyObject * obj0 = 0 ;
16429 char * kwnames[] = {
16430 (char *) "bitmap", NULL
16431 };
16432
16433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
16434 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
16435 if (!SWIG_IsOK(res1)) {
16436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16437 }
16438 if (!argp1) {
16439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16440 }
16441 arg1 = reinterpret_cast< wxBitmap * >(argp1);
16442 {
16443 if (!wxPyCheckForApp()) SWIG_fail;
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
16446 wxPyEndAllowThreads(__tstate);
16447 if (PyErr_Occurred()) SWIG_fail;
16448 }
16449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16450 return resultobj;
16451 fail:
16452 return NULL;
16453 }
16454
16455
16456 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16457 PyObject *resultobj = 0;
16458 int arg1 ;
16459 int arg2 ;
16460 buffer arg3 ;
16461 int arg4 ;
16462 wxImage *result = 0 ;
16463 int val1 ;
16464 int ecode1 = 0 ;
16465 int val2 ;
16466 int ecode2 = 0 ;
16467 Py_ssize_t temp3 ;
16468 PyObject * obj0 = 0 ;
16469 PyObject * obj1 = 0 ;
16470 PyObject * obj2 = 0 ;
16471 char * kwnames[] = {
16472 (char *) "width",(char *) "height",(char *) "data", NULL
16473 };
16474
16475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16476 ecode1 = SWIG_AsVal_int(obj0, &val1);
16477 if (!SWIG_IsOK(ecode1)) {
16478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
16479 }
16480 arg1 = static_cast< int >(val1);
16481 ecode2 = SWIG_AsVal_int(obj1, &val2);
16482 if (!SWIG_IsOK(ecode2)) {
16483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
16484 }
16485 arg2 = static_cast< int >(val2);
16486 {
16487 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16488 arg4 = (int)temp3;
16489 }
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj = 0;
16505 int arg1 ;
16506 int arg2 ;
16507 buffer arg3 ;
16508 int arg4 ;
16509 buffer arg5 ;
16510 int arg6 ;
16511 wxImage *result = 0 ;
16512 int val1 ;
16513 int ecode1 = 0 ;
16514 int val2 ;
16515 int ecode2 = 0 ;
16516 Py_ssize_t temp3 ;
16517 Py_ssize_t temp5 ;
16518 PyObject * obj0 = 0 ;
16519 PyObject * obj1 = 0 ;
16520 PyObject * obj2 = 0 ;
16521 PyObject * obj3 = 0 ;
16522 char * kwnames[] = {
16523 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
16524 };
16525
16526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16527 ecode1 = SWIG_AsVal_int(obj0, &val1);
16528 if (!SWIG_IsOK(ecode1)) {
16529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
16530 }
16531 arg1 = static_cast< int >(val1);
16532 ecode2 = SWIG_AsVal_int(obj1, &val2);
16533 if (!SWIG_IsOK(ecode2)) {
16534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
16535 }
16536 arg2 = static_cast< int >(val2);
16537 {
16538 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16539 arg4 = (int)temp3;
16540 }
16541 {
16542 if (obj3 != Py_None) {
16543 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16544 arg6 = (int)temp5;
16545 }
16546 }
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16550 wxPyEndAllowThreads(__tstate);
16551 if (PyErr_Occurred()) SWIG_fail;
16552 }
16553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16554 return resultobj;
16555 fail:
16556 return NULL;
16557 }
16558
16559
16560 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16561 PyObject *resultobj = 0;
16562 wxImage *arg1 = (wxImage *) 0 ;
16563 int arg2 ;
16564 int arg3 ;
16565 bool arg4 = (bool) true ;
16566 void *argp1 = 0 ;
16567 int res1 = 0 ;
16568 int val2 ;
16569 int ecode2 = 0 ;
16570 int val3 ;
16571 int ecode3 = 0 ;
16572 bool val4 ;
16573 int ecode4 = 0 ;
16574 PyObject * obj0 = 0 ;
16575 PyObject * obj1 = 0 ;
16576 PyObject * obj2 = 0 ;
16577 PyObject * obj3 = 0 ;
16578 char * kwnames[] = {
16579 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16580 };
16581
16582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16584 if (!SWIG_IsOK(res1)) {
16585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16586 }
16587 arg1 = reinterpret_cast< wxImage * >(argp1);
16588 ecode2 = SWIG_AsVal_int(obj1, &val2);
16589 if (!SWIG_IsOK(ecode2)) {
16590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16591 }
16592 arg2 = static_cast< int >(val2);
16593 ecode3 = SWIG_AsVal_int(obj2, &val3);
16594 if (!SWIG_IsOK(ecode3)) {
16595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16596 }
16597 arg3 = static_cast< int >(val3);
16598 if (obj3) {
16599 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16600 if (!SWIG_IsOK(ecode4)) {
16601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16602 }
16603 arg4 = static_cast< bool >(val4);
16604 }
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 (arg1)->Create(arg2,arg3,arg4);
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 resultobj = SWIG_Py_Void();
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16619 PyObject *resultobj = 0;
16620 wxImage *arg1 = (wxImage *) 0 ;
16621 void *argp1 = 0 ;
16622 int res1 = 0 ;
16623 PyObject *swig_obj[1] ;
16624
16625 if (!args) SWIG_fail;
16626 swig_obj[0] = args;
16627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16628 if (!SWIG_IsOK(res1)) {
16629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16630 }
16631 arg1 = reinterpret_cast< wxImage * >(argp1);
16632 {
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 (arg1)->Destroy();
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 resultobj = SWIG_Py_Void();
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj = 0;
16647 wxImage *arg1 = (wxImage *) 0 ;
16648 int arg2 ;
16649 int arg3 ;
16650 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16651 SwigValueWrapper<wxImage > result;
16652 void *argp1 = 0 ;
16653 int res1 = 0 ;
16654 int val2 ;
16655 int ecode2 = 0 ;
16656 int val3 ;
16657 int ecode3 = 0 ;
16658 int val4 ;
16659 int ecode4 = 0 ;
16660 PyObject * obj0 = 0 ;
16661 PyObject * obj1 = 0 ;
16662 PyObject * obj2 = 0 ;
16663 PyObject * obj3 = 0 ;
16664 char * kwnames[] = {
16665 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16666 };
16667
16668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16670 if (!SWIG_IsOK(res1)) {
16671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16672 }
16673 arg1 = reinterpret_cast< wxImage * >(argp1);
16674 ecode2 = SWIG_AsVal_int(obj1, &val2);
16675 if (!SWIG_IsOK(ecode2)) {
16676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16677 }
16678 arg2 = static_cast< int >(val2);
16679 ecode3 = SWIG_AsVal_int(obj2, &val3);
16680 if (!SWIG_IsOK(ecode3)) {
16681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16682 }
16683 arg3 = static_cast< int >(val3);
16684 if (obj3) {
16685 ecode4 = SWIG_AsVal_int(obj3, &val4);
16686 if (!SWIG_IsOK(ecode4)) {
16687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16688 }
16689 arg4 = static_cast< int >(val4);
16690 }
16691 {
16692 PyThreadState* __tstate = wxPyBeginAllowThreads();
16693 result = (arg1)->Scale(arg2,arg3,arg4);
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16698 return resultobj;
16699 fail:
16700 return NULL;
16701 }
16702
16703
16704 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16705 PyObject *resultobj = 0;
16706 wxImage *arg1 = (wxImage *) 0 ;
16707 int arg2 ;
16708 int arg3 ;
16709 SwigValueWrapper<wxImage > result;
16710 void *argp1 = 0 ;
16711 int res1 = 0 ;
16712 int val2 ;
16713 int ecode2 = 0 ;
16714 int val3 ;
16715 int ecode3 = 0 ;
16716 PyObject * obj0 = 0 ;
16717 PyObject * obj1 = 0 ;
16718 PyObject * obj2 = 0 ;
16719 char * kwnames[] = {
16720 (char *) "self",(char *) "width",(char *) "height", NULL
16721 };
16722
16723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16725 if (!SWIG_IsOK(res1)) {
16726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16727 }
16728 arg1 = reinterpret_cast< wxImage * >(argp1);
16729 ecode2 = SWIG_AsVal_int(obj1, &val2);
16730 if (!SWIG_IsOK(ecode2)) {
16731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16732 }
16733 arg2 = static_cast< int >(val2);
16734 ecode3 = SWIG_AsVal_int(obj2, &val3);
16735 if (!SWIG_IsOK(ecode3)) {
16736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16737 }
16738 arg3 = static_cast< int >(val3);
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj = 0;
16754 wxImage *arg1 = (wxImage *) 0 ;
16755 int arg2 ;
16756 int arg3 ;
16757 SwigValueWrapper<wxImage > result;
16758 void *argp1 = 0 ;
16759 int res1 = 0 ;
16760 int val2 ;
16761 int ecode2 = 0 ;
16762 int val3 ;
16763 int ecode3 = 0 ;
16764 PyObject * obj0 = 0 ;
16765 PyObject * obj1 = 0 ;
16766 PyObject * obj2 = 0 ;
16767 char * kwnames[] = {
16768 (char *) "self",(char *) "width",(char *) "height", NULL
16769 };
16770
16771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16773 if (!SWIG_IsOK(res1)) {
16774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16775 }
16776 arg1 = reinterpret_cast< wxImage * >(argp1);
16777 ecode2 = SWIG_AsVal_int(obj1, &val2);
16778 if (!SWIG_IsOK(ecode2)) {
16779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16780 }
16781 arg2 = static_cast< int >(val2);
16782 ecode3 = SWIG_AsVal_int(obj2, &val3);
16783 if (!SWIG_IsOK(ecode3)) {
16784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16785 }
16786 arg3 = static_cast< int >(val3);
16787 {
16788 PyThreadState* __tstate = wxPyBeginAllowThreads();
16789 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16790 wxPyEndAllowThreads(__tstate);
16791 if (PyErr_Occurred()) SWIG_fail;
16792 }
16793 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16794 return resultobj;
16795 fail:
16796 return NULL;
16797 }
16798
16799
16800 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16801 PyObject *resultobj = 0;
16802 wxImage *arg1 = (wxImage *) 0 ;
16803 int arg2 ;
16804 SwigValueWrapper<wxImage > result;
16805 void *argp1 = 0 ;
16806 int res1 = 0 ;
16807 int val2 ;
16808 int ecode2 = 0 ;
16809 PyObject * obj0 = 0 ;
16810 PyObject * obj1 = 0 ;
16811 char * kwnames[] = {
16812 (char *) "self",(char *) "radius", NULL
16813 };
16814
16815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16817 if (!SWIG_IsOK(res1)) {
16818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16819 }
16820 arg1 = reinterpret_cast< wxImage * >(argp1);
16821 ecode2 = SWIG_AsVal_int(obj1, &val2);
16822 if (!SWIG_IsOK(ecode2)) {
16823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16824 }
16825 arg2 = static_cast< int >(val2);
16826 {
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = (arg1)->Blur(arg2);
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16840 PyObject *resultobj = 0;
16841 wxImage *arg1 = (wxImage *) 0 ;
16842 int arg2 ;
16843 SwigValueWrapper<wxImage > result;
16844 void *argp1 = 0 ;
16845 int res1 = 0 ;
16846 int val2 ;
16847 int ecode2 = 0 ;
16848 PyObject * obj0 = 0 ;
16849 PyObject * obj1 = 0 ;
16850 char * kwnames[] = {
16851 (char *) "self",(char *) "radius", NULL
16852 };
16853
16854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16856 if (!SWIG_IsOK(res1)) {
16857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16858 }
16859 arg1 = reinterpret_cast< wxImage * >(argp1);
16860 ecode2 = SWIG_AsVal_int(obj1, &val2);
16861 if (!SWIG_IsOK(ecode2)) {
16862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16863 }
16864 arg2 = static_cast< int >(val2);
16865 {
16866 PyThreadState* __tstate = wxPyBeginAllowThreads();
16867 result = (arg1)->BlurHorizontal(arg2);
16868 wxPyEndAllowThreads(__tstate);
16869 if (PyErr_Occurred()) SWIG_fail;
16870 }
16871 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16872 return resultobj;
16873 fail:
16874 return NULL;
16875 }
16876
16877
16878 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj = 0;
16880 wxImage *arg1 = (wxImage *) 0 ;
16881 int arg2 ;
16882 SwigValueWrapper<wxImage > result;
16883 void *argp1 = 0 ;
16884 int res1 = 0 ;
16885 int val2 ;
16886 int ecode2 = 0 ;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 char * kwnames[] = {
16890 (char *) "self",(char *) "radius", NULL
16891 };
16892
16893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16895 if (!SWIG_IsOK(res1)) {
16896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16897 }
16898 arg1 = reinterpret_cast< wxImage * >(argp1);
16899 ecode2 = SWIG_AsVal_int(obj1, &val2);
16900 if (!SWIG_IsOK(ecode2)) {
16901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16902 }
16903 arg2 = static_cast< int >(val2);
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = (arg1)->BlurVertical(arg2);
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj = 0;
16919 wxImage *arg1 = (wxImage *) 0 ;
16920 int arg2 ;
16921 int arg3 ;
16922 SwigValueWrapper<wxImage > result;
16923 void *argp1 = 0 ;
16924 int res1 = 0 ;
16925 int val2 ;
16926 int ecode2 = 0 ;
16927 int val3 ;
16928 int ecode3 = 0 ;
16929 PyObject * obj0 = 0 ;
16930 PyObject * obj1 = 0 ;
16931 PyObject * obj2 = 0 ;
16932 char * kwnames[] = {
16933 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16934 };
16935
16936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16938 if (!SWIG_IsOK(res1)) {
16939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16940 }
16941 arg1 = reinterpret_cast< wxImage * >(argp1);
16942 ecode2 = SWIG_AsVal_int(obj1, &val2);
16943 if (!SWIG_IsOK(ecode2)) {
16944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16945 }
16946 arg2 = static_cast< int >(val2);
16947 ecode3 = SWIG_AsVal_int(obj2, &val3);
16948 if (!SWIG_IsOK(ecode3)) {
16949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16950 }
16951 arg3 = static_cast< int >(val3);
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16959 return resultobj;
16960 fail:
16961 return NULL;
16962 }
16963
16964
16965 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj = 0;
16967 wxImage *arg1 = (wxImage *) 0 ;
16968 int arg2 ;
16969 int arg3 ;
16970 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16971 wxImage *result = 0 ;
16972 void *argp1 = 0 ;
16973 int res1 = 0 ;
16974 int val2 ;
16975 int ecode2 = 0 ;
16976 int val3 ;
16977 int ecode3 = 0 ;
16978 int val4 ;
16979 int ecode4 = 0 ;
16980 PyObject * obj0 = 0 ;
16981 PyObject * obj1 = 0 ;
16982 PyObject * obj2 = 0 ;
16983 PyObject * obj3 = 0 ;
16984 char * kwnames[] = {
16985 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16986 };
16987
16988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16990 if (!SWIG_IsOK(res1)) {
16991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16992 }
16993 arg1 = reinterpret_cast< wxImage * >(argp1);
16994 ecode2 = SWIG_AsVal_int(obj1, &val2);
16995 if (!SWIG_IsOK(ecode2)) {
16996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16997 }
16998 arg2 = static_cast< int >(val2);
16999 ecode3 = SWIG_AsVal_int(obj2, &val3);
17000 if (!SWIG_IsOK(ecode3)) {
17001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
17002 }
17003 arg3 = static_cast< int >(val3);
17004 if (obj3) {
17005 ecode4 = SWIG_AsVal_int(obj3, &val4);
17006 if (!SWIG_IsOK(ecode4)) {
17007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
17008 }
17009 arg4 = static_cast< int >(val4);
17010 }
17011 {
17012 PyThreadState* __tstate = wxPyBeginAllowThreads();
17013 {
17014 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
17015 result = (wxImage *) &_result_ref;
17016 }
17017 wxPyEndAllowThreads(__tstate);
17018 if (PyErr_Occurred()) SWIG_fail;
17019 }
17020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj = 0;
17029 wxImage *arg1 = (wxImage *) 0 ;
17030 wxSize *arg2 = 0 ;
17031 wxPoint *arg3 = 0 ;
17032 int arg4 = (int) -1 ;
17033 int arg5 = (int) -1 ;
17034 int arg6 = (int) -1 ;
17035 wxImage *result = 0 ;
17036 void *argp1 = 0 ;
17037 int res1 = 0 ;
17038 wxSize temp2 ;
17039 wxPoint temp3 ;
17040 int val4 ;
17041 int ecode4 = 0 ;
17042 int val5 ;
17043 int ecode5 = 0 ;
17044 int val6 ;
17045 int ecode6 = 0 ;
17046 PyObject * obj0 = 0 ;
17047 PyObject * obj1 = 0 ;
17048 PyObject * obj2 = 0 ;
17049 PyObject * obj3 = 0 ;
17050 PyObject * obj4 = 0 ;
17051 PyObject * obj5 = 0 ;
17052 char * kwnames[] = {
17053 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
17054 };
17055
17056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17058 if (!SWIG_IsOK(res1)) {
17059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
17060 }
17061 arg1 = reinterpret_cast< wxImage * >(argp1);
17062 {
17063 arg2 = &temp2;
17064 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17065 }
17066 {
17067 arg3 = &temp3;
17068 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17069 }
17070 if (obj3) {
17071 ecode4 = SWIG_AsVal_int(obj3, &val4);
17072 if (!SWIG_IsOK(ecode4)) {
17073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
17074 }
17075 arg4 = static_cast< int >(val4);
17076 }
17077 if (obj4) {
17078 ecode5 = SWIG_AsVal_int(obj4, &val5);
17079 if (!SWIG_IsOK(ecode5)) {
17080 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
17081 }
17082 arg5 = static_cast< int >(val5);
17083 }
17084 if (obj5) {
17085 ecode6 = SWIG_AsVal_int(obj5, &val6);
17086 if (!SWIG_IsOK(ecode6)) {
17087 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
17088 }
17089 arg6 = static_cast< int >(val6);
17090 }
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 {
17094 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
17095 result = (wxImage *) &_result_ref;
17096 }
17097 wxPyEndAllowThreads(__tstate);
17098 if (PyErr_Occurred()) SWIG_fail;
17099 }
17100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17101 return resultobj;
17102 fail:
17103 return NULL;
17104 }
17105
17106
17107 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj = 0;
17109 wxImage *arg1 = (wxImage *) 0 ;
17110 int arg2 ;
17111 int arg3 ;
17112 byte arg4 ;
17113 byte arg5 ;
17114 byte arg6 ;
17115 void *argp1 = 0 ;
17116 int res1 = 0 ;
17117 int val2 ;
17118 int ecode2 = 0 ;
17119 int val3 ;
17120 int ecode3 = 0 ;
17121 unsigned char val4 ;
17122 int ecode4 = 0 ;
17123 unsigned char val5 ;
17124 int ecode5 = 0 ;
17125 unsigned char val6 ;
17126 int ecode6 = 0 ;
17127 PyObject * obj0 = 0 ;
17128 PyObject * obj1 = 0 ;
17129 PyObject * obj2 = 0 ;
17130 PyObject * obj3 = 0 ;
17131 PyObject * obj4 = 0 ;
17132 PyObject * obj5 = 0 ;
17133 char * kwnames[] = {
17134 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
17135 };
17136
17137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17139 if (!SWIG_IsOK(res1)) {
17140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
17141 }
17142 arg1 = reinterpret_cast< wxImage * >(argp1);
17143 ecode2 = SWIG_AsVal_int(obj1, &val2);
17144 if (!SWIG_IsOK(ecode2)) {
17145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
17146 }
17147 arg2 = static_cast< int >(val2);
17148 ecode3 = SWIG_AsVal_int(obj2, &val3);
17149 if (!SWIG_IsOK(ecode3)) {
17150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
17151 }
17152 arg3 = static_cast< int >(val3);
17153 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17154 if (!SWIG_IsOK(ecode4)) {
17155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
17156 }
17157 arg4 = static_cast< byte >(val4);
17158 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17159 if (!SWIG_IsOK(ecode5)) {
17160 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
17161 }
17162 arg5 = static_cast< byte >(val5);
17163 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
17164 if (!SWIG_IsOK(ecode6)) {
17165 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
17166 }
17167 arg6 = static_cast< byte >(val6);
17168 {
17169 PyThreadState* __tstate = wxPyBeginAllowThreads();
17170 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
17171 wxPyEndAllowThreads(__tstate);
17172 if (PyErr_Occurred()) SWIG_fail;
17173 }
17174 resultobj = SWIG_Py_Void();
17175 return resultobj;
17176 fail:
17177 return NULL;
17178 }
17179
17180
17181 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj = 0;
17183 wxImage *arg1 = (wxImage *) 0 ;
17184 wxRect *arg2 = 0 ;
17185 byte arg3 ;
17186 byte arg4 ;
17187 byte arg5 ;
17188 void *argp1 = 0 ;
17189 int res1 = 0 ;
17190 wxRect temp2 ;
17191 unsigned char val3 ;
17192 int ecode3 = 0 ;
17193 unsigned char val4 ;
17194 int ecode4 = 0 ;
17195 unsigned char val5 ;
17196 int ecode5 = 0 ;
17197 PyObject * obj0 = 0 ;
17198 PyObject * obj1 = 0 ;
17199 PyObject * obj2 = 0 ;
17200 PyObject * obj3 = 0 ;
17201 PyObject * obj4 = 0 ;
17202 char * kwnames[] = {
17203 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
17204 };
17205
17206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17208 if (!SWIG_IsOK(res1)) {
17209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
17210 }
17211 arg1 = reinterpret_cast< wxImage * >(argp1);
17212 {
17213 arg2 = &temp2;
17214 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17215 }
17216 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17217 if (!SWIG_IsOK(ecode3)) {
17218 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
17219 }
17220 arg3 = static_cast< byte >(val3);
17221 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17222 if (!SWIG_IsOK(ecode4)) {
17223 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
17224 }
17225 arg4 = static_cast< byte >(val4);
17226 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17227 if (!SWIG_IsOK(ecode5)) {
17228 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
17229 }
17230 arg5 = static_cast< byte >(val5);
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 resultobj = SWIG_Py_Void();
17238 return resultobj;
17239 fail:
17240 return NULL;
17241 }
17242
17243
17244 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17245 PyObject *resultobj = 0;
17246 wxImage *arg1 = (wxImage *) 0 ;
17247 int arg2 ;
17248 int arg3 ;
17249 byte result;
17250 void *argp1 = 0 ;
17251 int res1 = 0 ;
17252 int val2 ;
17253 int ecode2 = 0 ;
17254 int val3 ;
17255 int ecode3 = 0 ;
17256 PyObject * obj0 = 0 ;
17257 PyObject * obj1 = 0 ;
17258 PyObject * obj2 = 0 ;
17259 char * kwnames[] = {
17260 (char *) "self",(char *) "x",(char *) "y", NULL
17261 };
17262
17263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17265 if (!SWIG_IsOK(res1)) {
17266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
17267 }
17268 arg1 = reinterpret_cast< wxImage * >(argp1);
17269 ecode2 = SWIG_AsVal_int(obj1, &val2);
17270 if (!SWIG_IsOK(ecode2)) {
17271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
17272 }
17273 arg2 = static_cast< int >(val2);
17274 ecode3 = SWIG_AsVal_int(obj2, &val3);
17275 if (!SWIG_IsOK(ecode3)) {
17276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
17277 }
17278 arg3 = static_cast< int >(val3);
17279 {
17280 PyThreadState* __tstate = wxPyBeginAllowThreads();
17281 result = (byte)(arg1)->GetRed(arg2,arg3);
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17286 return resultobj;
17287 fail:
17288 return NULL;
17289 }
17290
17291
17292 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17293 PyObject *resultobj = 0;
17294 wxImage *arg1 = (wxImage *) 0 ;
17295 int arg2 ;
17296 int arg3 ;
17297 byte result;
17298 void *argp1 = 0 ;
17299 int res1 = 0 ;
17300 int val2 ;
17301 int ecode2 = 0 ;
17302 int val3 ;
17303 int ecode3 = 0 ;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 PyObject * obj2 = 0 ;
17307 char * kwnames[] = {
17308 (char *) "self",(char *) "x",(char *) "y", NULL
17309 };
17310
17311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17313 if (!SWIG_IsOK(res1)) {
17314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
17315 }
17316 arg1 = reinterpret_cast< wxImage * >(argp1);
17317 ecode2 = SWIG_AsVal_int(obj1, &val2);
17318 if (!SWIG_IsOK(ecode2)) {
17319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
17320 }
17321 arg2 = static_cast< int >(val2);
17322 ecode3 = SWIG_AsVal_int(obj2, &val3);
17323 if (!SWIG_IsOK(ecode3)) {
17324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
17325 }
17326 arg3 = static_cast< int >(val3);
17327 {
17328 PyThreadState* __tstate = wxPyBeginAllowThreads();
17329 result = (byte)(arg1)->GetGreen(arg2,arg3);
17330 wxPyEndAllowThreads(__tstate);
17331 if (PyErr_Occurred()) SWIG_fail;
17332 }
17333 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17334 return resultobj;
17335 fail:
17336 return NULL;
17337 }
17338
17339
17340 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17341 PyObject *resultobj = 0;
17342 wxImage *arg1 = (wxImage *) 0 ;
17343 int arg2 ;
17344 int arg3 ;
17345 byte result;
17346 void *argp1 = 0 ;
17347 int res1 = 0 ;
17348 int val2 ;
17349 int ecode2 = 0 ;
17350 int val3 ;
17351 int ecode3 = 0 ;
17352 PyObject * obj0 = 0 ;
17353 PyObject * obj1 = 0 ;
17354 PyObject * obj2 = 0 ;
17355 char * kwnames[] = {
17356 (char *) "self",(char *) "x",(char *) "y", NULL
17357 };
17358
17359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17361 if (!SWIG_IsOK(res1)) {
17362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
17363 }
17364 arg1 = reinterpret_cast< wxImage * >(argp1);
17365 ecode2 = SWIG_AsVal_int(obj1, &val2);
17366 if (!SWIG_IsOK(ecode2)) {
17367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
17368 }
17369 arg2 = static_cast< int >(val2);
17370 ecode3 = SWIG_AsVal_int(obj2, &val3);
17371 if (!SWIG_IsOK(ecode3)) {
17372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
17373 }
17374 arg3 = static_cast< int >(val3);
17375 {
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 result = (byte)(arg1)->GetBlue(arg2,arg3);
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17382 return resultobj;
17383 fail:
17384 return NULL;
17385 }
17386
17387
17388 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj = 0;
17390 wxImage *arg1 = (wxImage *) 0 ;
17391 int arg2 ;
17392 int arg3 ;
17393 byte arg4 ;
17394 void *argp1 = 0 ;
17395 int res1 = 0 ;
17396 int val2 ;
17397 int ecode2 = 0 ;
17398 int val3 ;
17399 int ecode3 = 0 ;
17400 unsigned char val4 ;
17401 int ecode4 = 0 ;
17402 PyObject * obj0 = 0 ;
17403 PyObject * obj1 = 0 ;
17404 PyObject * obj2 = 0 ;
17405 PyObject * obj3 = 0 ;
17406 char * kwnames[] = {
17407 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
17408 };
17409
17410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17412 if (!SWIG_IsOK(res1)) {
17413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17414 }
17415 arg1 = reinterpret_cast< wxImage * >(argp1);
17416 ecode2 = SWIG_AsVal_int(obj1, &val2);
17417 if (!SWIG_IsOK(ecode2)) {
17418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
17419 }
17420 arg2 = static_cast< int >(val2);
17421 ecode3 = SWIG_AsVal_int(obj2, &val3);
17422 if (!SWIG_IsOK(ecode3)) {
17423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
17424 }
17425 arg3 = static_cast< int >(val3);
17426 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17427 if (!SWIG_IsOK(ecode4)) {
17428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
17429 }
17430 arg4 = static_cast< byte >(val4);
17431 {
17432 PyThreadState* __tstate = wxPyBeginAllowThreads();
17433 (arg1)->SetAlpha(arg2,arg3,arg4);
17434 wxPyEndAllowThreads(__tstate);
17435 if (PyErr_Occurred()) SWIG_fail;
17436 }
17437 resultobj = SWIG_Py_Void();
17438 return resultobj;
17439 fail:
17440 return NULL;
17441 }
17442
17443
17444 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17445 PyObject *resultobj = 0;
17446 wxImage *arg1 = (wxImage *) 0 ;
17447 int arg2 ;
17448 int arg3 ;
17449 byte result;
17450 void *argp1 = 0 ;
17451 int res1 = 0 ;
17452 int val2 ;
17453 int ecode2 = 0 ;
17454 int val3 ;
17455 int ecode3 = 0 ;
17456 PyObject * obj0 = 0 ;
17457 PyObject * obj1 = 0 ;
17458 PyObject * obj2 = 0 ;
17459 char * kwnames[] = {
17460 (char *) "self",(char *) "x",(char *) "y", NULL
17461 };
17462
17463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17465 if (!SWIG_IsOK(res1)) {
17466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17467 }
17468 arg1 = reinterpret_cast< wxImage * >(argp1);
17469 ecode2 = SWIG_AsVal_int(obj1, &val2);
17470 if (!SWIG_IsOK(ecode2)) {
17471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
17472 }
17473 arg2 = static_cast< int >(val2);
17474 ecode3 = SWIG_AsVal_int(obj2, &val3);
17475 if (!SWIG_IsOK(ecode3)) {
17476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
17477 }
17478 arg3 = static_cast< int >(val3);
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (byte)(arg1)->GetAlpha(arg2,arg3);
17482 wxPyEndAllowThreads(__tstate);
17483 if (PyErr_Occurred()) SWIG_fail;
17484 }
17485 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17486 return resultobj;
17487 fail:
17488 return NULL;
17489 }
17490
17491
17492 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17493 PyObject *resultobj = 0;
17494 wxImage *arg1 = (wxImage *) 0 ;
17495 bool result;
17496 void *argp1 = 0 ;
17497 int res1 = 0 ;
17498 PyObject *swig_obj[1] ;
17499
17500 if (!args) SWIG_fail;
17501 swig_obj[0] = args;
17502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17503 if (!SWIG_IsOK(res1)) {
17504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17505 }
17506 arg1 = reinterpret_cast< wxImage * >(argp1);
17507 {
17508 PyThreadState* __tstate = wxPyBeginAllowThreads();
17509 result = (bool)(arg1)->HasAlpha();
17510 wxPyEndAllowThreads(__tstate);
17511 if (PyErr_Occurred()) SWIG_fail;
17512 }
17513 {
17514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17515 }
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17523 PyObject *resultobj = 0;
17524 wxImage *arg1 = (wxImage *) 0 ;
17525 void *argp1 = 0 ;
17526 int res1 = 0 ;
17527 PyObject *swig_obj[1] ;
17528
17529 if (!args) SWIG_fail;
17530 swig_obj[0] = args;
17531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17532 if (!SWIG_IsOK(res1)) {
17533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17534 }
17535 arg1 = reinterpret_cast< wxImage * >(argp1);
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 (arg1)->InitAlpha();
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 resultobj = SWIG_Py_Void();
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj = 0;
17551 wxImage *arg1 = (wxImage *) 0 ;
17552 int arg2 ;
17553 int arg3 ;
17554 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17555 bool result;
17556 void *argp1 = 0 ;
17557 int res1 = 0 ;
17558 int val2 ;
17559 int ecode2 = 0 ;
17560 int val3 ;
17561 int ecode3 = 0 ;
17562 unsigned char val4 ;
17563 int ecode4 = 0 ;
17564 PyObject * obj0 = 0 ;
17565 PyObject * obj1 = 0 ;
17566 PyObject * obj2 = 0 ;
17567 PyObject * obj3 = 0 ;
17568 char * kwnames[] = {
17569 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17570 };
17571
17572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17574 if (!SWIG_IsOK(res1)) {
17575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17576 }
17577 arg1 = reinterpret_cast< wxImage * >(argp1);
17578 ecode2 = SWIG_AsVal_int(obj1, &val2);
17579 if (!SWIG_IsOK(ecode2)) {
17580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17581 }
17582 arg2 = static_cast< int >(val2);
17583 ecode3 = SWIG_AsVal_int(obj2, &val3);
17584 if (!SWIG_IsOK(ecode3)) {
17585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17586 }
17587 arg3 = static_cast< int >(val3);
17588 if (obj3) {
17589 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17590 if (!SWIG_IsOK(ecode4)) {
17591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17592 }
17593 arg4 = static_cast< byte >(val4);
17594 }
17595 {
17596 PyThreadState* __tstate = wxPyBeginAllowThreads();
17597 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 {
17602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17603 }
17604 return resultobj;
17605 fail:
17606 return NULL;
17607 }
17608
17609
17610 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17611 PyObject *resultobj = 0;
17612 wxImage *arg1 = (wxImage *) 0 ;
17613 byte *arg2 = (byte *) 0 ;
17614 byte *arg3 = (byte *) 0 ;
17615 byte *arg4 = (byte *) 0 ;
17616 byte arg5 = (byte) 0 ;
17617 byte arg6 = (byte) 0 ;
17618 byte arg7 = (byte) 0 ;
17619 bool result;
17620 void *argp1 = 0 ;
17621 int res1 = 0 ;
17622 byte temp2 ;
17623 int res2 = SWIG_TMPOBJ ;
17624 byte temp3 ;
17625 int res3 = SWIG_TMPOBJ ;
17626 byte temp4 ;
17627 int res4 = SWIG_TMPOBJ ;
17628 unsigned char val5 ;
17629 int ecode5 = 0 ;
17630 unsigned char val6 ;
17631 int ecode6 = 0 ;
17632 unsigned char val7 ;
17633 int ecode7 = 0 ;
17634 PyObject * obj0 = 0 ;
17635 PyObject * obj1 = 0 ;
17636 PyObject * obj2 = 0 ;
17637 PyObject * obj3 = 0 ;
17638 char * kwnames[] = {
17639 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17640 };
17641
17642 arg2 = &temp2;
17643 arg3 = &temp3;
17644 arg4 = &temp4;
17645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17647 if (!SWIG_IsOK(res1)) {
17648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17649 }
17650 arg1 = reinterpret_cast< wxImage * >(argp1);
17651 if (obj1) {
17652 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17653 if (!SWIG_IsOK(ecode5)) {
17654 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17655 }
17656 arg5 = static_cast< byte >(val5);
17657 }
17658 if (obj2) {
17659 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17660 if (!SWIG_IsOK(ecode6)) {
17661 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17662 }
17663 arg6 = static_cast< byte >(val6);
17664 }
17665 if (obj3) {
17666 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17667 if (!SWIG_IsOK(ecode7)) {
17668 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17669 }
17670 arg7 = static_cast< byte >(val7);
17671 }
17672 {
17673 PyThreadState* __tstate = wxPyBeginAllowThreads();
17674 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17675 wxPyEndAllowThreads(__tstate);
17676 if (PyErr_Occurred()) SWIG_fail;
17677 }
17678 {
17679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17680 }
17681 if (SWIG_IsTmpObj(res2)) {
17682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17683 } else {
17684 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17685 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17686 }
17687 if (SWIG_IsTmpObj(res3)) {
17688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17689 } else {
17690 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17692 }
17693 if (SWIG_IsTmpObj(res4)) {
17694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17695 } else {
17696 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17698 }
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17706 PyObject *resultobj = 0;
17707 wxImage *arg1 = (wxImage *) 0 ;
17708 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17709 bool result;
17710 void *argp1 = 0 ;
17711 int res1 = 0 ;
17712 unsigned char val2 ;
17713 int ecode2 = 0 ;
17714 PyObject * obj0 = 0 ;
17715 PyObject * obj1 = 0 ;
17716 char * kwnames[] = {
17717 (char *) "self",(char *) "threshold", NULL
17718 };
17719
17720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17722 if (!SWIG_IsOK(res1)) {
17723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17724 }
17725 arg1 = reinterpret_cast< wxImage * >(argp1);
17726 if (obj1) {
17727 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17728 if (!SWIG_IsOK(ecode2)) {
17729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17730 }
17731 arg2 = static_cast< byte >(val2);
17732 }
17733 {
17734 PyThreadState* __tstate = wxPyBeginAllowThreads();
17735 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17736 wxPyEndAllowThreads(__tstate);
17737 if (PyErr_Occurred()) SWIG_fail;
17738 }
17739 {
17740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17741 }
17742 return resultobj;
17743 fail:
17744 return NULL;
17745 }
17746
17747
17748 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17749 PyObject *resultobj = 0;
17750 wxImage *arg1 = (wxImage *) 0 ;
17751 byte arg2 ;
17752 byte arg3 ;
17753 byte arg4 ;
17754 bool result;
17755 void *argp1 = 0 ;
17756 int res1 = 0 ;
17757 unsigned char val2 ;
17758 int ecode2 = 0 ;
17759 unsigned char val3 ;
17760 int ecode3 = 0 ;
17761 unsigned char val4 ;
17762 int ecode4 = 0 ;
17763 PyObject * obj0 = 0 ;
17764 PyObject * obj1 = 0 ;
17765 PyObject * obj2 = 0 ;
17766 PyObject * obj3 = 0 ;
17767 char * kwnames[] = {
17768 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17769 };
17770
17771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17773 if (!SWIG_IsOK(res1)) {
17774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17775 }
17776 arg1 = reinterpret_cast< wxImage * >(argp1);
17777 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17778 if (!SWIG_IsOK(ecode2)) {
17779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17780 }
17781 arg2 = static_cast< byte >(val2);
17782 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17783 if (!SWIG_IsOK(ecode3)) {
17784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17785 }
17786 arg3 = static_cast< byte >(val3);
17787 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17788 if (!SWIG_IsOK(ecode4)) {
17789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17790 }
17791 arg4 = static_cast< byte >(val4);
17792 {
17793 PyThreadState* __tstate = wxPyBeginAllowThreads();
17794 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 {
17799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17800 }
17801 return resultobj;
17802 fail:
17803 return NULL;
17804 }
17805
17806
17807 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17808 PyObject *resultobj = 0;
17809 wxImage *arg1 = (wxImage *) 0 ;
17810 wxImage *arg2 = 0 ;
17811 byte arg3 ;
17812 byte arg4 ;
17813 byte arg5 ;
17814 bool result;
17815 void *argp1 = 0 ;
17816 int res1 = 0 ;
17817 void *argp2 = 0 ;
17818 int res2 = 0 ;
17819 unsigned char val3 ;
17820 int ecode3 = 0 ;
17821 unsigned char val4 ;
17822 int ecode4 = 0 ;
17823 unsigned char val5 ;
17824 int ecode5 = 0 ;
17825 PyObject * obj0 = 0 ;
17826 PyObject * obj1 = 0 ;
17827 PyObject * obj2 = 0 ;
17828 PyObject * obj3 = 0 ;
17829 PyObject * obj4 = 0 ;
17830 char * kwnames[] = {
17831 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17832 };
17833
17834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17836 if (!SWIG_IsOK(res1)) {
17837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17838 }
17839 arg1 = reinterpret_cast< wxImage * >(argp1);
17840 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17841 if (!SWIG_IsOK(res2)) {
17842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17843 }
17844 if (!argp2) {
17845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17846 }
17847 arg2 = reinterpret_cast< wxImage * >(argp2);
17848 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17849 if (!SWIG_IsOK(ecode3)) {
17850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17851 }
17852 arg3 = static_cast< byte >(val3);
17853 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17854 if (!SWIG_IsOK(ecode4)) {
17855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17856 }
17857 arg4 = static_cast< byte >(val4);
17858 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17859 if (!SWIG_IsOK(ecode5)) {
17860 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17861 }
17862 arg5 = static_cast< byte >(val5);
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 {
17870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17871 }
17872 return resultobj;
17873 fail:
17874 return NULL;
17875 }
17876
17877
17878 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17879 PyObject *resultobj = 0;
17880 wxString *arg1 = 0 ;
17881 bool result;
17882 bool temp1 = false ;
17883 PyObject * obj0 = 0 ;
17884 char * kwnames[] = {
17885 (char *) "filename", NULL
17886 };
17887
17888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17889 {
17890 arg1 = wxString_in_helper(obj0);
17891 if (arg1 == NULL) SWIG_fail;
17892 temp1 = true;
17893 }
17894 {
17895 PyThreadState* __tstate = wxPyBeginAllowThreads();
17896 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 {
17901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17902 }
17903 {
17904 if (temp1)
17905 delete arg1;
17906 }
17907 return resultobj;
17908 fail:
17909 {
17910 if (temp1)
17911 delete arg1;
17912 }
17913 return NULL;
17914 }
17915
17916
17917 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17918 PyObject *resultobj = 0;
17919 wxString *arg1 = 0 ;
17920 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17921 int result;
17922 bool temp1 = false ;
17923 long val2 ;
17924 int ecode2 = 0 ;
17925 PyObject * obj0 = 0 ;
17926 PyObject * obj1 = 0 ;
17927 char * kwnames[] = {
17928 (char *) "filename",(char *) "type", NULL
17929 };
17930
17931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17932 {
17933 arg1 = wxString_in_helper(obj0);
17934 if (arg1 == NULL) SWIG_fail;
17935 temp1 = true;
17936 }
17937 if (obj1) {
17938 ecode2 = SWIG_AsVal_long(obj1, &val2);
17939 if (!SWIG_IsOK(ecode2)) {
17940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17941 }
17942 arg2 = static_cast< long >(val2);
17943 }
17944 {
17945 PyThreadState* __tstate = wxPyBeginAllowThreads();
17946 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17947 wxPyEndAllowThreads(__tstate);
17948 if (PyErr_Occurred()) SWIG_fail;
17949 }
17950 resultobj = SWIG_From_int(static_cast< int >(result));
17951 {
17952 if (temp1)
17953 delete arg1;
17954 }
17955 return resultobj;
17956 fail:
17957 {
17958 if (temp1)
17959 delete arg1;
17960 }
17961 return NULL;
17962 }
17963
17964
17965 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj = 0;
17967 wxImage *arg1 = (wxImage *) 0 ;
17968 wxString *arg2 = 0 ;
17969 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17970 int arg4 = (int) -1 ;
17971 bool result;
17972 void *argp1 = 0 ;
17973 int res1 = 0 ;
17974 bool temp2 = false ;
17975 long val3 ;
17976 int ecode3 = 0 ;
17977 int val4 ;
17978 int ecode4 = 0 ;
17979 PyObject * obj0 = 0 ;
17980 PyObject * obj1 = 0 ;
17981 PyObject * obj2 = 0 ;
17982 PyObject * obj3 = 0 ;
17983 char * kwnames[] = {
17984 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17985 };
17986
17987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17989 if (!SWIG_IsOK(res1)) {
17990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17991 }
17992 arg1 = reinterpret_cast< wxImage * >(argp1);
17993 {
17994 arg2 = wxString_in_helper(obj1);
17995 if (arg2 == NULL) SWIG_fail;
17996 temp2 = true;
17997 }
17998 if (obj2) {
17999 ecode3 = SWIG_AsVal_long(obj2, &val3);
18000 if (!SWIG_IsOK(ecode3)) {
18001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
18002 }
18003 arg3 = static_cast< long >(val3);
18004 }
18005 if (obj3) {
18006 ecode4 = SWIG_AsVal_int(obj3, &val4);
18007 if (!SWIG_IsOK(ecode4)) {
18008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
18009 }
18010 arg4 = static_cast< int >(val4);
18011 }
18012 {
18013 PyThreadState* __tstate = wxPyBeginAllowThreads();
18014 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
18015 wxPyEndAllowThreads(__tstate);
18016 if (PyErr_Occurred()) SWIG_fail;
18017 }
18018 {
18019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18020 }
18021 {
18022 if (temp2)
18023 delete arg2;
18024 }
18025 return resultobj;
18026 fail:
18027 {
18028 if (temp2)
18029 delete arg2;
18030 }
18031 return NULL;
18032 }
18033
18034
18035 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18036 PyObject *resultobj = 0;
18037 wxImage *arg1 = (wxImage *) 0 ;
18038 wxString *arg2 = 0 ;
18039 wxString *arg3 = 0 ;
18040 int arg4 = (int) -1 ;
18041 bool result;
18042 void *argp1 = 0 ;
18043 int res1 = 0 ;
18044 bool temp2 = false ;
18045 bool temp3 = false ;
18046 int val4 ;
18047 int ecode4 = 0 ;
18048 PyObject * obj0 = 0 ;
18049 PyObject * obj1 = 0 ;
18050 PyObject * obj2 = 0 ;
18051 PyObject * obj3 = 0 ;
18052 char * kwnames[] = {
18053 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
18054 };
18055
18056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18058 if (!SWIG_IsOK(res1)) {
18059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18060 }
18061 arg1 = reinterpret_cast< wxImage * >(argp1);
18062 {
18063 arg2 = wxString_in_helper(obj1);
18064 if (arg2 == NULL) SWIG_fail;
18065 temp2 = true;
18066 }
18067 {
18068 arg3 = wxString_in_helper(obj2);
18069 if (arg3 == NULL) SWIG_fail;
18070 temp3 = true;
18071 }
18072 if (obj3) {
18073 ecode4 = SWIG_AsVal_int(obj3, &val4);
18074 if (!SWIG_IsOK(ecode4)) {
18075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
18076 }
18077 arg4 = static_cast< int >(val4);
18078 }
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18082 wxPyEndAllowThreads(__tstate);
18083 if (PyErr_Occurred()) SWIG_fail;
18084 }
18085 {
18086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18087 }
18088 {
18089 if (temp2)
18090 delete arg2;
18091 }
18092 {
18093 if (temp3)
18094 delete arg3;
18095 }
18096 return resultobj;
18097 fail:
18098 {
18099 if (temp2)
18100 delete arg2;
18101 }
18102 {
18103 if (temp3)
18104 delete arg3;
18105 }
18106 return NULL;
18107 }
18108
18109
18110 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18111 PyObject *resultobj = 0;
18112 wxImage *arg1 = (wxImage *) 0 ;
18113 wxString *arg2 = 0 ;
18114 int arg3 ;
18115 bool result;
18116 void *argp1 = 0 ;
18117 int res1 = 0 ;
18118 bool temp2 = false ;
18119 int val3 ;
18120 int ecode3 = 0 ;
18121 PyObject * obj0 = 0 ;
18122 PyObject * obj1 = 0 ;
18123 PyObject * obj2 = 0 ;
18124 char * kwnames[] = {
18125 (char *) "self",(char *) "name",(char *) "type", NULL
18126 };
18127
18128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18130 if (!SWIG_IsOK(res1)) {
18131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
18132 }
18133 arg1 = reinterpret_cast< wxImage * >(argp1);
18134 {
18135 arg2 = wxString_in_helper(obj1);
18136 if (arg2 == NULL) SWIG_fail;
18137 temp2 = true;
18138 }
18139 ecode3 = SWIG_AsVal_int(obj2, &val3);
18140 if (!SWIG_IsOK(ecode3)) {
18141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
18142 }
18143 arg3 = static_cast< int >(val3);
18144 {
18145 PyThreadState* __tstate = wxPyBeginAllowThreads();
18146 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 {
18151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18152 }
18153 {
18154 if (temp2)
18155 delete arg2;
18156 }
18157 return resultobj;
18158 fail:
18159 {
18160 if (temp2)
18161 delete arg2;
18162 }
18163 return NULL;
18164 }
18165
18166
18167 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18168 PyObject *resultobj = 0;
18169 wxImage *arg1 = (wxImage *) 0 ;
18170 wxString *arg2 = 0 ;
18171 wxString *arg3 = 0 ;
18172 bool result;
18173 void *argp1 = 0 ;
18174 int res1 = 0 ;
18175 bool temp2 = false ;
18176 bool temp3 = false ;
18177 PyObject * obj0 = 0 ;
18178 PyObject * obj1 = 0 ;
18179 PyObject * obj2 = 0 ;
18180 char * kwnames[] = {
18181 (char *) "self",(char *) "name",(char *) "mimetype", NULL
18182 };
18183
18184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18186 if (!SWIG_IsOK(res1)) {
18187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18188 }
18189 arg1 = reinterpret_cast< wxImage * >(argp1);
18190 {
18191 arg2 = wxString_in_helper(obj1);
18192 if (arg2 == NULL) SWIG_fail;
18193 temp2 = true;
18194 }
18195 {
18196 arg3 = wxString_in_helper(obj2);
18197 if (arg3 == NULL) SWIG_fail;
18198 temp3 = true;
18199 }
18200 {
18201 PyThreadState* __tstate = wxPyBeginAllowThreads();
18202 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
18203 wxPyEndAllowThreads(__tstate);
18204 if (PyErr_Occurred()) SWIG_fail;
18205 }
18206 {
18207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18208 }
18209 {
18210 if (temp2)
18211 delete arg2;
18212 }
18213 {
18214 if (temp3)
18215 delete arg3;
18216 }
18217 return resultobj;
18218 fail:
18219 {
18220 if (temp2)
18221 delete arg2;
18222 }
18223 {
18224 if (temp3)
18225 delete arg3;
18226 }
18227 return NULL;
18228 }
18229
18230
18231 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18232 PyObject *resultobj = 0;
18233 wxInputStream *arg1 = 0 ;
18234 bool result;
18235 wxPyInputStream *temp1 ;
18236 bool created1 ;
18237 PyObject * obj0 = 0 ;
18238 char * kwnames[] = {
18239 (char *) "stream", NULL
18240 };
18241
18242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
18243 {
18244 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
18245 arg1 = temp1->m_wxis;
18246 created1 = false;
18247 } else {
18248 PyErr_Clear(); // clear the failure of the wxPyConvert above
18249 arg1 = wxPyCBInputStream_create(obj0, false);
18250 if (arg1 == NULL) {
18251 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18252 SWIG_fail;
18253 }
18254 created1 = true;
18255 }
18256 }
18257 {
18258 PyThreadState* __tstate = wxPyBeginAllowThreads();
18259 result = (bool)wxImage::CanRead(*arg1);
18260 wxPyEndAllowThreads(__tstate);
18261 if (PyErr_Occurred()) SWIG_fail;
18262 }
18263 {
18264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18265 }
18266 {
18267 if (created1) delete arg1;
18268 }
18269 return resultobj;
18270 fail:
18271 {
18272 if (created1) delete arg1;
18273 }
18274 return NULL;
18275 }
18276
18277
18278 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj = 0;
18280 wxImage *arg1 = (wxImage *) 0 ;
18281 wxInputStream *arg2 = 0 ;
18282 long arg3 = (long) wxBITMAP_TYPE_ANY ;
18283 int arg4 = (int) -1 ;
18284 bool result;
18285 void *argp1 = 0 ;
18286 int res1 = 0 ;
18287 wxPyInputStream *temp2 ;
18288 bool created2 ;
18289 long val3 ;
18290 int ecode3 = 0 ;
18291 int val4 ;
18292 int ecode4 = 0 ;
18293 PyObject * obj0 = 0 ;
18294 PyObject * obj1 = 0 ;
18295 PyObject * obj2 = 0 ;
18296 PyObject * obj3 = 0 ;
18297 char * kwnames[] = {
18298 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
18299 };
18300
18301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
18305 }
18306 arg1 = reinterpret_cast< wxImage * >(argp1);
18307 {
18308 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18309 arg2 = temp2->m_wxis;
18310 created2 = false;
18311 } else {
18312 PyErr_Clear(); // clear the failure of the wxPyConvert above
18313 arg2 = wxPyCBInputStream_create(obj1, false);
18314 if (arg2 == NULL) {
18315 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18316 SWIG_fail;
18317 }
18318 created2 = true;
18319 }
18320 }
18321 if (obj2) {
18322 ecode3 = SWIG_AsVal_long(obj2, &val3);
18323 if (!SWIG_IsOK(ecode3)) {
18324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
18325 }
18326 arg3 = static_cast< long >(val3);
18327 }
18328 if (obj3) {
18329 ecode4 = SWIG_AsVal_int(obj3, &val4);
18330 if (!SWIG_IsOK(ecode4)) {
18331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
18332 }
18333 arg4 = static_cast< int >(val4);
18334 }
18335 {
18336 PyThreadState* __tstate = wxPyBeginAllowThreads();
18337 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
18338 wxPyEndAllowThreads(__tstate);
18339 if (PyErr_Occurred()) SWIG_fail;
18340 }
18341 {
18342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18343 }
18344 {
18345 if (created2) delete arg2;
18346 }
18347 return resultobj;
18348 fail:
18349 {
18350 if (created2) delete arg2;
18351 }
18352 return NULL;
18353 }
18354
18355
18356 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18357 PyObject *resultobj = 0;
18358 wxImage *arg1 = (wxImage *) 0 ;
18359 wxInputStream *arg2 = 0 ;
18360 wxString *arg3 = 0 ;
18361 int arg4 = (int) -1 ;
18362 bool result;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 wxPyInputStream *temp2 ;
18366 bool created2 ;
18367 bool temp3 = false ;
18368 int val4 ;
18369 int ecode4 = 0 ;
18370 PyObject * obj0 = 0 ;
18371 PyObject * obj1 = 0 ;
18372 PyObject * obj2 = 0 ;
18373 PyObject * obj3 = 0 ;
18374 char * kwnames[] = {
18375 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
18376 };
18377
18378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18380 if (!SWIG_IsOK(res1)) {
18381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
18382 }
18383 arg1 = reinterpret_cast< wxImage * >(argp1);
18384 {
18385 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18386 arg2 = temp2->m_wxis;
18387 created2 = false;
18388 } else {
18389 PyErr_Clear(); // clear the failure of the wxPyConvert above
18390 arg2 = wxPyCBInputStream_create(obj1, false);
18391 if (arg2 == NULL) {
18392 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18393 SWIG_fail;
18394 }
18395 created2 = true;
18396 }
18397 }
18398 {
18399 arg3 = wxString_in_helper(obj2);
18400 if (arg3 == NULL) SWIG_fail;
18401 temp3 = true;
18402 }
18403 if (obj3) {
18404 ecode4 = SWIG_AsVal_int(obj3, &val4);
18405 if (!SWIG_IsOK(ecode4)) {
18406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
18407 }
18408 arg4 = static_cast< int >(val4);
18409 }
18410 {
18411 PyThreadState* __tstate = wxPyBeginAllowThreads();
18412 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
18413 wxPyEndAllowThreads(__tstate);
18414 if (PyErr_Occurred()) SWIG_fail;
18415 }
18416 {
18417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18418 }
18419 {
18420 if (created2) delete arg2;
18421 }
18422 {
18423 if (temp3)
18424 delete arg3;
18425 }
18426 return resultobj;
18427 fail:
18428 {
18429 if (created2) delete arg2;
18430 }
18431 {
18432 if (temp3)
18433 delete arg3;
18434 }
18435 return NULL;
18436 }
18437
18438
18439 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18440 PyObject *resultobj = 0;
18441 wxImage *arg1 = (wxImage *) 0 ;
18442 bool result;
18443 void *argp1 = 0 ;
18444 int res1 = 0 ;
18445 PyObject *swig_obj[1] ;
18446
18447 if (!args) SWIG_fail;
18448 swig_obj[0] = args;
18449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18450 if (!SWIG_IsOK(res1)) {
18451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
18452 }
18453 arg1 = reinterpret_cast< wxImage * >(argp1);
18454 {
18455 PyThreadState* __tstate = wxPyBeginAllowThreads();
18456 result = (bool)(arg1)->IsOk();
18457 wxPyEndAllowThreads(__tstate);
18458 if (PyErr_Occurred()) SWIG_fail;
18459 }
18460 {
18461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18462 }
18463 return resultobj;
18464 fail:
18465 return NULL;
18466 }
18467
18468
18469 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18470 PyObject *resultobj = 0;
18471 wxImage *arg1 = (wxImage *) 0 ;
18472 int result;
18473 void *argp1 = 0 ;
18474 int res1 = 0 ;
18475 PyObject *swig_obj[1] ;
18476
18477 if (!args) SWIG_fail;
18478 swig_obj[0] = args;
18479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18480 if (!SWIG_IsOK(res1)) {
18481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
18482 }
18483 arg1 = reinterpret_cast< wxImage * >(argp1);
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 result = (int)(arg1)->GetWidth();
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 resultobj = SWIG_From_int(static_cast< int >(result));
18491 return resultobj;
18492 fail:
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18498 PyObject *resultobj = 0;
18499 wxImage *arg1 = (wxImage *) 0 ;
18500 int result;
18501 void *argp1 = 0 ;
18502 int res1 = 0 ;
18503 PyObject *swig_obj[1] ;
18504
18505 if (!args) SWIG_fail;
18506 swig_obj[0] = args;
18507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18508 if (!SWIG_IsOK(res1)) {
18509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
18510 }
18511 arg1 = reinterpret_cast< wxImage * >(argp1);
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 result = (int)(arg1)->GetHeight();
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 resultobj = SWIG_From_int(static_cast< int >(result));
18519 return resultobj;
18520 fail:
18521 return NULL;
18522 }
18523
18524
18525 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18526 PyObject *resultobj = 0;
18527 wxImage *arg1 = (wxImage *) 0 ;
18528 wxSize result;
18529 void *argp1 = 0 ;
18530 int res1 = 0 ;
18531 PyObject *swig_obj[1] ;
18532
18533 if (!args) SWIG_fail;
18534 swig_obj[0] = args;
18535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18536 if (!SWIG_IsOK(res1)) {
18537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18538 }
18539 arg1 = reinterpret_cast< wxImage * >(argp1);
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 result = wxImage_GetSize(arg1);
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18547 return resultobj;
18548 fail:
18549 return NULL;
18550 }
18551
18552
18553 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18554 PyObject *resultobj = 0;
18555 wxImage *arg1 = (wxImage *) 0 ;
18556 wxRect *arg2 = 0 ;
18557 SwigValueWrapper<wxImage > result;
18558 void *argp1 = 0 ;
18559 int res1 = 0 ;
18560 wxRect temp2 ;
18561 PyObject * obj0 = 0 ;
18562 PyObject * obj1 = 0 ;
18563 char * kwnames[] = {
18564 (char *) "self",(char *) "rect", NULL
18565 };
18566
18567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18569 if (!SWIG_IsOK(res1)) {
18570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18571 }
18572 arg1 = reinterpret_cast< wxImage * >(argp1);
18573 {
18574 arg2 = &temp2;
18575 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18576 }
18577 {
18578 PyThreadState* __tstate = wxPyBeginAllowThreads();
18579 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18580 wxPyEndAllowThreads(__tstate);
18581 if (PyErr_Occurred()) SWIG_fail;
18582 }
18583 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18584 return resultobj;
18585 fail:
18586 return NULL;
18587 }
18588
18589
18590 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18591 PyObject *resultobj = 0;
18592 wxImage *arg1 = (wxImage *) 0 ;
18593 wxSize *arg2 = 0 ;
18594 wxPoint *arg3 = 0 ;
18595 int arg4 = (int) -1 ;
18596 int arg5 = (int) -1 ;
18597 int arg6 = (int) -1 ;
18598 SwigValueWrapper<wxImage > result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 wxSize temp2 ;
18602 wxPoint temp3 ;
18603 int val4 ;
18604 int ecode4 = 0 ;
18605 int val5 ;
18606 int ecode5 = 0 ;
18607 int val6 ;
18608 int ecode6 = 0 ;
18609 PyObject * obj0 = 0 ;
18610 PyObject * obj1 = 0 ;
18611 PyObject * obj2 = 0 ;
18612 PyObject * obj3 = 0 ;
18613 PyObject * obj4 = 0 ;
18614 PyObject * obj5 = 0 ;
18615 char * kwnames[] = {
18616 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18617 };
18618
18619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18623 }
18624 arg1 = reinterpret_cast< wxImage * >(argp1);
18625 {
18626 arg2 = &temp2;
18627 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18628 }
18629 {
18630 arg3 = &temp3;
18631 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18632 }
18633 if (obj3) {
18634 ecode4 = SWIG_AsVal_int(obj3, &val4);
18635 if (!SWIG_IsOK(ecode4)) {
18636 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18637 }
18638 arg4 = static_cast< int >(val4);
18639 }
18640 if (obj4) {
18641 ecode5 = SWIG_AsVal_int(obj4, &val5);
18642 if (!SWIG_IsOK(ecode5)) {
18643 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18644 }
18645 arg5 = static_cast< int >(val5);
18646 }
18647 if (obj5) {
18648 ecode6 = SWIG_AsVal_int(obj5, &val6);
18649 if (!SWIG_IsOK(ecode6)) {
18650 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18651 }
18652 arg6 = static_cast< int >(val6);
18653 }
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18657 wxPyEndAllowThreads(__tstate);
18658 if (PyErr_Occurred()) SWIG_fail;
18659 }
18660 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18661 return resultobj;
18662 fail:
18663 return NULL;
18664 }
18665
18666
18667 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18668 PyObject *resultobj = 0;
18669 wxImage *arg1 = (wxImage *) 0 ;
18670 SwigValueWrapper<wxImage > result;
18671 void *argp1 = 0 ;
18672 int res1 = 0 ;
18673 PyObject *swig_obj[1] ;
18674
18675 if (!args) SWIG_fail;
18676 swig_obj[0] = args;
18677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18678 if (!SWIG_IsOK(res1)) {
18679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18680 }
18681 arg1 = reinterpret_cast< wxImage * >(argp1);
18682 {
18683 PyThreadState* __tstate = wxPyBeginAllowThreads();
18684 result = (arg1)->Copy();
18685 wxPyEndAllowThreads(__tstate);
18686 if (PyErr_Occurred()) SWIG_fail;
18687 }
18688 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18689 return resultobj;
18690 fail:
18691 return NULL;
18692 }
18693
18694
18695 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18696 PyObject *resultobj = 0;
18697 wxImage *arg1 = (wxImage *) 0 ;
18698 wxImage *arg2 = 0 ;
18699 int arg3 ;
18700 int arg4 ;
18701 void *argp1 = 0 ;
18702 int res1 = 0 ;
18703 void *argp2 = 0 ;
18704 int res2 = 0 ;
18705 int val3 ;
18706 int ecode3 = 0 ;
18707 int val4 ;
18708 int ecode4 = 0 ;
18709 PyObject * obj0 = 0 ;
18710 PyObject * obj1 = 0 ;
18711 PyObject * obj2 = 0 ;
18712 PyObject * obj3 = 0 ;
18713 char * kwnames[] = {
18714 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18715 };
18716
18717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18721 }
18722 arg1 = reinterpret_cast< wxImage * >(argp1);
18723 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18724 if (!SWIG_IsOK(res2)) {
18725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18726 }
18727 if (!argp2) {
18728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18729 }
18730 arg2 = reinterpret_cast< wxImage * >(argp2);
18731 ecode3 = SWIG_AsVal_int(obj2, &val3);
18732 if (!SWIG_IsOK(ecode3)) {
18733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18734 }
18735 arg3 = static_cast< int >(val3);
18736 ecode4 = SWIG_AsVal_int(obj3, &val4);
18737 if (!SWIG_IsOK(ecode4)) {
18738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18739 }
18740 arg4 = static_cast< int >(val4);
18741 {
18742 PyThreadState* __tstate = wxPyBeginAllowThreads();
18743 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18744 wxPyEndAllowThreads(__tstate);
18745 if (PyErr_Occurred()) SWIG_fail;
18746 }
18747 resultobj = SWIG_Py_Void();
18748 return resultobj;
18749 fail:
18750 return NULL;
18751 }
18752
18753
18754 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18755 PyObject *resultobj = 0;
18756 wxImage *arg1 = (wxImage *) 0 ;
18757 PyObject *result = 0 ;
18758 void *argp1 = 0 ;
18759 int res1 = 0 ;
18760 PyObject *swig_obj[1] ;
18761
18762 if (!args) SWIG_fail;
18763 swig_obj[0] = args;
18764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18765 if (!SWIG_IsOK(res1)) {
18766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18767 }
18768 arg1 = reinterpret_cast< wxImage * >(argp1);
18769 {
18770 PyThreadState* __tstate = wxPyBeginAllowThreads();
18771 result = (PyObject *)wxImage_GetData(arg1);
18772 wxPyEndAllowThreads(__tstate);
18773 if (PyErr_Occurred()) SWIG_fail;
18774 }
18775 resultobj = result;
18776 return resultobj;
18777 fail:
18778 return NULL;
18779 }
18780
18781
18782 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18783 PyObject *resultobj = 0;
18784 wxImage *arg1 = (wxImage *) 0 ;
18785 buffer arg2 ;
18786 int arg3 ;
18787 void *argp1 = 0 ;
18788 int res1 = 0 ;
18789 Py_ssize_t temp2 ;
18790 PyObject * obj0 = 0 ;
18791 PyObject * obj1 = 0 ;
18792 char * kwnames[] = {
18793 (char *) "self",(char *) "data", NULL
18794 };
18795
18796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18798 if (!SWIG_IsOK(res1)) {
18799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18800 }
18801 arg1 = reinterpret_cast< wxImage * >(argp1);
18802 {
18803 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18804 arg3 = (int)temp2;
18805 }
18806 {
18807 PyThreadState* __tstate = wxPyBeginAllowThreads();
18808 wxImage_SetData(arg1,arg2,arg3);
18809 wxPyEndAllowThreads(__tstate);
18810 if (PyErr_Occurred()) SWIG_fail;
18811 }
18812 resultobj = SWIG_Py_Void();
18813 return resultobj;
18814 fail:
18815 return NULL;
18816 }
18817
18818
18819 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18820 PyObject *resultobj = 0;
18821 wxImage *arg1 = (wxImage *) 0 ;
18822 PyObject *result = 0 ;
18823 void *argp1 = 0 ;
18824 int res1 = 0 ;
18825 PyObject *swig_obj[1] ;
18826
18827 if (!args) SWIG_fail;
18828 swig_obj[0] = args;
18829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18830 if (!SWIG_IsOK(res1)) {
18831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18832 }
18833 arg1 = reinterpret_cast< wxImage * >(argp1);
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18837 wxPyEndAllowThreads(__tstate);
18838 if (PyErr_Occurred()) SWIG_fail;
18839 }
18840 resultobj = result;
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18848 PyObject *resultobj = 0;
18849 wxImage *arg1 = (wxImage *) 0 ;
18850 buffer arg2 ;
18851 int arg3 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 Py_ssize_t temp2 ;
18855 PyObject * obj0 = 0 ;
18856 PyObject * obj1 = 0 ;
18857 char * kwnames[] = {
18858 (char *) "self",(char *) "data", NULL
18859 };
18860
18861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18863 if (!SWIG_IsOK(res1)) {
18864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18865 }
18866 arg1 = reinterpret_cast< wxImage * >(argp1);
18867 {
18868 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18869 arg3 = (int)temp2;
18870 }
18871 {
18872 PyThreadState* __tstate = wxPyBeginAllowThreads();
18873 wxImage_SetDataBuffer(arg1,arg2,arg3);
18874 wxPyEndAllowThreads(__tstate);
18875 if (PyErr_Occurred()) SWIG_fail;
18876 }
18877 resultobj = SWIG_Py_Void();
18878 return resultobj;
18879 fail:
18880 return NULL;
18881 }
18882
18883
18884 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18885 PyObject *resultobj = 0;
18886 wxImage *arg1 = (wxImage *) 0 ;
18887 PyObject *result = 0 ;
18888 void *argp1 = 0 ;
18889 int res1 = 0 ;
18890 PyObject *swig_obj[1] ;
18891
18892 if (!args) SWIG_fail;
18893 swig_obj[0] = args;
18894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18895 if (!SWIG_IsOK(res1)) {
18896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18897 }
18898 arg1 = reinterpret_cast< wxImage * >(argp1);
18899 {
18900 PyThreadState* __tstate = wxPyBeginAllowThreads();
18901 result = (PyObject *)wxImage_GetAlphaData(arg1);
18902 wxPyEndAllowThreads(__tstate);
18903 if (PyErr_Occurred()) SWIG_fail;
18904 }
18905 resultobj = result;
18906 return resultobj;
18907 fail:
18908 return NULL;
18909 }
18910
18911
18912 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18913 PyObject *resultobj = 0;
18914 wxImage *arg1 = (wxImage *) 0 ;
18915 buffer arg2 ;
18916 int arg3 ;
18917 void *argp1 = 0 ;
18918 int res1 = 0 ;
18919 Py_ssize_t temp2 ;
18920 PyObject * obj0 = 0 ;
18921 PyObject * obj1 = 0 ;
18922 char * kwnames[] = {
18923 (char *) "self",(char *) "alpha", NULL
18924 };
18925
18926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18928 if (!SWIG_IsOK(res1)) {
18929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18930 }
18931 arg1 = reinterpret_cast< wxImage * >(argp1);
18932 {
18933 if (obj1 != Py_None) {
18934 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18935 arg3 = (int)temp2;
18936 }
18937 }
18938 {
18939 PyThreadState* __tstate = wxPyBeginAllowThreads();
18940 wxImage_SetAlphaData(arg1,arg2,arg3);
18941 wxPyEndAllowThreads(__tstate);
18942 if (PyErr_Occurred()) SWIG_fail;
18943 }
18944 resultobj = SWIG_Py_Void();
18945 return resultobj;
18946 fail:
18947 return NULL;
18948 }
18949
18950
18951 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18952 PyObject *resultobj = 0;
18953 wxImage *arg1 = (wxImage *) 0 ;
18954 PyObject *result = 0 ;
18955 void *argp1 = 0 ;
18956 int res1 = 0 ;
18957 PyObject *swig_obj[1] ;
18958
18959 if (!args) SWIG_fail;
18960 swig_obj[0] = args;
18961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18962 if (!SWIG_IsOK(res1)) {
18963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18964 }
18965 arg1 = reinterpret_cast< wxImage * >(argp1);
18966 {
18967 PyThreadState* __tstate = wxPyBeginAllowThreads();
18968 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 resultobj = result;
18973 return resultobj;
18974 fail:
18975 return NULL;
18976 }
18977
18978
18979 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18980 PyObject *resultobj = 0;
18981 wxImage *arg1 = (wxImage *) 0 ;
18982 buffer arg2 ;
18983 int arg3 ;
18984 void *argp1 = 0 ;
18985 int res1 = 0 ;
18986 Py_ssize_t temp2 ;
18987 PyObject * obj0 = 0 ;
18988 PyObject * obj1 = 0 ;
18989 char * kwnames[] = {
18990 (char *) "self",(char *) "alpha", NULL
18991 };
18992
18993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18995 if (!SWIG_IsOK(res1)) {
18996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18997 }
18998 arg1 = reinterpret_cast< wxImage * >(argp1);
18999 {
19000 if (obj1 != Py_None) {
19001 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
19002 arg3 = (int)temp2;
19003 }
19004 }
19005 {
19006 PyThreadState* __tstate = wxPyBeginAllowThreads();
19007 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
19008 wxPyEndAllowThreads(__tstate);
19009 if (PyErr_Occurred()) SWIG_fail;
19010 }
19011 resultobj = SWIG_Py_Void();
19012 return resultobj;
19013 fail:
19014 return NULL;
19015 }
19016
19017
19018 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19019 PyObject *resultobj = 0;
19020 wxImage *arg1 = (wxImage *) 0 ;
19021 byte arg2 ;
19022 byte arg3 ;
19023 byte arg4 ;
19024 void *argp1 = 0 ;
19025 int res1 = 0 ;
19026 unsigned char val2 ;
19027 int ecode2 = 0 ;
19028 unsigned char val3 ;
19029 int ecode3 = 0 ;
19030 unsigned char val4 ;
19031 int ecode4 = 0 ;
19032 PyObject * obj0 = 0 ;
19033 PyObject * obj1 = 0 ;
19034 PyObject * obj2 = 0 ;
19035 PyObject * obj3 = 0 ;
19036 char * kwnames[] = {
19037 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19038 };
19039
19040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19042 if (!SWIG_IsOK(res1)) {
19043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
19044 }
19045 arg1 = reinterpret_cast< wxImage * >(argp1);
19046 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19047 if (!SWIG_IsOK(ecode2)) {
19048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
19049 }
19050 arg2 = static_cast< byte >(val2);
19051 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19052 if (!SWIG_IsOK(ecode3)) {
19053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
19054 }
19055 arg3 = static_cast< byte >(val3);
19056 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19057 if (!SWIG_IsOK(ecode4)) {
19058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
19059 }
19060 arg4 = static_cast< byte >(val4);
19061 {
19062 PyThreadState* __tstate = wxPyBeginAllowThreads();
19063 (arg1)->SetMaskColour(arg2,arg3,arg4);
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 resultobj = SWIG_Py_Void();
19068 return resultobj;
19069 fail:
19070 return NULL;
19071 }
19072
19073
19074 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19075 PyObject *resultobj = 0;
19076 wxImage *arg1 = (wxImage *) 0 ;
19077 byte *arg2 = (byte *) 0 ;
19078 byte *arg3 = (byte *) 0 ;
19079 byte *arg4 = (byte *) 0 ;
19080 void *argp1 = 0 ;
19081 int res1 = 0 ;
19082 byte temp2 ;
19083 int res2 = SWIG_TMPOBJ ;
19084 byte temp3 ;
19085 int res3 = SWIG_TMPOBJ ;
19086 byte temp4 ;
19087 int res4 = SWIG_TMPOBJ ;
19088 PyObject *swig_obj[1] ;
19089
19090 arg2 = &temp2;
19091 arg3 = &temp3;
19092 arg4 = &temp4;
19093 if (!args) SWIG_fail;
19094 swig_obj[0] = args;
19095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19096 if (!SWIG_IsOK(res1)) {
19097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
19098 }
19099 arg1 = reinterpret_cast< wxImage * >(argp1);
19100 {
19101 PyThreadState* __tstate = wxPyBeginAllowThreads();
19102 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
19103 wxPyEndAllowThreads(__tstate);
19104 if (PyErr_Occurred()) SWIG_fail;
19105 }
19106 resultobj = SWIG_Py_Void();
19107 if (SWIG_IsTmpObj(res2)) {
19108 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
19109 } else {
19110 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19111 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
19112 }
19113 if (SWIG_IsTmpObj(res3)) {
19114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
19115 } else {
19116 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
19118 }
19119 if (SWIG_IsTmpObj(res4)) {
19120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
19121 } else {
19122 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
19124 }
19125 return resultobj;
19126 fail:
19127 return NULL;
19128 }
19129
19130
19131 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19132 PyObject *resultobj = 0;
19133 wxImage *arg1 = (wxImage *) 0 ;
19134 byte result;
19135 void *argp1 = 0 ;
19136 int res1 = 0 ;
19137 PyObject *swig_obj[1] ;
19138
19139 if (!args) SWIG_fail;
19140 swig_obj[0] = args;
19141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19142 if (!SWIG_IsOK(res1)) {
19143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
19144 }
19145 arg1 = reinterpret_cast< wxImage * >(argp1);
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 result = (byte)(arg1)->GetMaskRed();
19149 wxPyEndAllowThreads(__tstate);
19150 if (PyErr_Occurred()) SWIG_fail;
19151 }
19152 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19153 return resultobj;
19154 fail:
19155 return NULL;
19156 }
19157
19158
19159 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19160 PyObject *resultobj = 0;
19161 wxImage *arg1 = (wxImage *) 0 ;
19162 byte result;
19163 void *argp1 = 0 ;
19164 int res1 = 0 ;
19165 PyObject *swig_obj[1] ;
19166
19167 if (!args) SWIG_fail;
19168 swig_obj[0] = args;
19169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
19172 }
19173 arg1 = reinterpret_cast< wxImage * >(argp1);
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (byte)(arg1)->GetMaskGreen();
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19181 return resultobj;
19182 fail:
19183 return NULL;
19184 }
19185
19186
19187 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19188 PyObject *resultobj = 0;
19189 wxImage *arg1 = (wxImage *) 0 ;
19190 byte result;
19191 void *argp1 = 0 ;
19192 int res1 = 0 ;
19193 PyObject *swig_obj[1] ;
19194
19195 if (!args) SWIG_fail;
19196 swig_obj[0] = args;
19197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19198 if (!SWIG_IsOK(res1)) {
19199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
19200 }
19201 arg1 = reinterpret_cast< wxImage * >(argp1);
19202 {
19203 PyThreadState* __tstate = wxPyBeginAllowThreads();
19204 result = (byte)(arg1)->GetMaskBlue();
19205 wxPyEndAllowThreads(__tstate);
19206 if (PyErr_Occurred()) SWIG_fail;
19207 }
19208 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19209 return resultobj;
19210 fail:
19211 return NULL;
19212 }
19213
19214
19215 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19216 PyObject *resultobj = 0;
19217 wxImage *arg1 = (wxImage *) 0 ;
19218 bool arg2 = (bool) true ;
19219 void *argp1 = 0 ;
19220 int res1 = 0 ;
19221 bool val2 ;
19222 int ecode2 = 0 ;
19223 PyObject * obj0 = 0 ;
19224 PyObject * obj1 = 0 ;
19225 char * kwnames[] = {
19226 (char *) "self",(char *) "mask", NULL
19227 };
19228
19229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
19230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19231 if (!SWIG_IsOK(res1)) {
19232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
19233 }
19234 arg1 = reinterpret_cast< wxImage * >(argp1);
19235 if (obj1) {
19236 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19237 if (!SWIG_IsOK(ecode2)) {
19238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
19239 }
19240 arg2 = static_cast< bool >(val2);
19241 }
19242 {
19243 PyThreadState* __tstate = wxPyBeginAllowThreads();
19244 (arg1)->SetMask(arg2);
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 resultobj = SWIG_Py_Void();
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19256 PyObject *resultobj = 0;
19257 wxImage *arg1 = (wxImage *) 0 ;
19258 bool result;
19259 void *argp1 = 0 ;
19260 int res1 = 0 ;
19261 PyObject *swig_obj[1] ;
19262
19263 if (!args) SWIG_fail;
19264 swig_obj[0] = args;
19265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19266 if (!SWIG_IsOK(res1)) {
19267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
19268 }
19269 arg1 = reinterpret_cast< wxImage * >(argp1);
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (bool)(arg1)->HasMask();
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 {
19277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19278 }
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj = 0;
19287 wxImage *arg1 = (wxImage *) 0 ;
19288 double arg2 ;
19289 wxPoint *arg3 = 0 ;
19290 bool arg4 = (bool) true ;
19291 wxPoint *arg5 = (wxPoint *) NULL ;
19292 SwigValueWrapper<wxImage > result;
19293 void *argp1 = 0 ;
19294 int res1 = 0 ;
19295 double val2 ;
19296 int ecode2 = 0 ;
19297 wxPoint temp3 ;
19298 bool val4 ;
19299 int ecode4 = 0 ;
19300 void *argp5 = 0 ;
19301 int res5 = 0 ;
19302 PyObject * obj0 = 0 ;
19303 PyObject * obj1 = 0 ;
19304 PyObject * obj2 = 0 ;
19305 PyObject * obj3 = 0 ;
19306 PyObject * obj4 = 0 ;
19307 char * kwnames[] = {
19308 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
19309 };
19310
19311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19313 if (!SWIG_IsOK(res1)) {
19314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
19315 }
19316 arg1 = reinterpret_cast< wxImage * >(argp1);
19317 ecode2 = SWIG_AsVal_double(obj1, &val2);
19318 if (!SWIG_IsOK(ecode2)) {
19319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
19320 }
19321 arg2 = static_cast< double >(val2);
19322 {
19323 arg3 = &temp3;
19324 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19325 }
19326 if (obj3) {
19327 ecode4 = SWIG_AsVal_bool(obj3, &val4);
19328 if (!SWIG_IsOK(ecode4)) {
19329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
19330 }
19331 arg4 = static_cast< bool >(val4);
19332 }
19333 if (obj4) {
19334 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
19335 if (!SWIG_IsOK(res5)) {
19336 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
19337 }
19338 arg5 = reinterpret_cast< wxPoint * >(argp5);
19339 }
19340 {
19341 PyThreadState* __tstate = wxPyBeginAllowThreads();
19342 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
19343 wxPyEndAllowThreads(__tstate);
19344 if (PyErr_Occurred()) SWIG_fail;
19345 }
19346 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19347 return resultobj;
19348 fail:
19349 return NULL;
19350 }
19351
19352
19353 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19354 PyObject *resultobj = 0;
19355 wxImage *arg1 = (wxImage *) 0 ;
19356 bool arg2 = (bool) true ;
19357 SwigValueWrapper<wxImage > result;
19358 void *argp1 = 0 ;
19359 int res1 = 0 ;
19360 bool val2 ;
19361 int ecode2 = 0 ;
19362 PyObject * obj0 = 0 ;
19363 PyObject * obj1 = 0 ;
19364 char * kwnames[] = {
19365 (char *) "self",(char *) "clockwise", NULL
19366 };
19367
19368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
19369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19370 if (!SWIG_IsOK(res1)) {
19371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
19372 }
19373 arg1 = reinterpret_cast< wxImage * >(argp1);
19374 if (obj1) {
19375 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19376 if (!SWIG_IsOK(ecode2)) {
19377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
19378 }
19379 arg2 = static_cast< bool >(val2);
19380 }
19381 {
19382 PyThreadState* __tstate = wxPyBeginAllowThreads();
19383 result = (arg1)->Rotate90(arg2);
19384 wxPyEndAllowThreads(__tstate);
19385 if (PyErr_Occurred()) SWIG_fail;
19386 }
19387 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19388 return resultobj;
19389 fail:
19390 return NULL;
19391 }
19392
19393
19394 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19395 PyObject *resultobj = 0;
19396 wxImage *arg1 = (wxImage *) 0 ;
19397 bool arg2 = (bool) true ;
19398 SwigValueWrapper<wxImage > result;
19399 void *argp1 = 0 ;
19400 int res1 = 0 ;
19401 bool val2 ;
19402 int ecode2 = 0 ;
19403 PyObject * obj0 = 0 ;
19404 PyObject * obj1 = 0 ;
19405 char * kwnames[] = {
19406 (char *) "self",(char *) "horizontally", NULL
19407 };
19408
19409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
19410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19411 if (!SWIG_IsOK(res1)) {
19412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
19413 }
19414 arg1 = reinterpret_cast< wxImage * >(argp1);
19415 if (obj1) {
19416 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19417 if (!SWIG_IsOK(ecode2)) {
19418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
19419 }
19420 arg2 = static_cast< bool >(val2);
19421 }
19422 {
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 result = (arg1)->Mirror(arg2);
19425 wxPyEndAllowThreads(__tstate);
19426 if (PyErr_Occurred()) SWIG_fail;
19427 }
19428 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19429 return resultobj;
19430 fail:
19431 return NULL;
19432 }
19433
19434
19435 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19436 PyObject *resultobj = 0;
19437 wxImage *arg1 = (wxImage *) 0 ;
19438 byte arg2 ;
19439 byte arg3 ;
19440 byte arg4 ;
19441 byte arg5 ;
19442 byte arg6 ;
19443 byte arg7 ;
19444 void *argp1 = 0 ;
19445 int res1 = 0 ;
19446 unsigned char val2 ;
19447 int ecode2 = 0 ;
19448 unsigned char val3 ;
19449 int ecode3 = 0 ;
19450 unsigned char val4 ;
19451 int ecode4 = 0 ;
19452 unsigned char val5 ;
19453 int ecode5 = 0 ;
19454 unsigned char val6 ;
19455 int ecode6 = 0 ;
19456 unsigned char val7 ;
19457 int ecode7 = 0 ;
19458 PyObject * obj0 = 0 ;
19459 PyObject * obj1 = 0 ;
19460 PyObject * obj2 = 0 ;
19461 PyObject * obj3 = 0 ;
19462 PyObject * obj4 = 0 ;
19463 PyObject * obj5 = 0 ;
19464 PyObject * obj6 = 0 ;
19465 char * kwnames[] = {
19466 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
19467 };
19468
19469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
19470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19471 if (!SWIG_IsOK(res1)) {
19472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
19473 }
19474 arg1 = reinterpret_cast< wxImage * >(argp1);
19475 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19476 if (!SWIG_IsOK(ecode2)) {
19477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
19478 }
19479 arg2 = static_cast< byte >(val2);
19480 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19481 if (!SWIG_IsOK(ecode3)) {
19482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
19483 }
19484 arg3 = static_cast< byte >(val3);
19485 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19486 if (!SWIG_IsOK(ecode4)) {
19487 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
19488 }
19489 arg4 = static_cast< byte >(val4);
19490 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
19491 if (!SWIG_IsOK(ecode5)) {
19492 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
19493 }
19494 arg5 = static_cast< byte >(val5);
19495 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
19496 if (!SWIG_IsOK(ecode6)) {
19497 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
19498 }
19499 arg6 = static_cast< byte >(val6);
19500 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
19501 if (!SWIG_IsOK(ecode7)) {
19502 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
19503 }
19504 arg7 = static_cast< byte >(val7);
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 resultobj = SWIG_Py_Void();
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19519 PyObject *resultobj = 0;
19520 wxImage *arg1 = (wxImage *) 0 ;
19521 double arg2 = (double) 0.299 ;
19522 double arg3 = (double) 0.587 ;
19523 double arg4 = (double) 0.114 ;
19524 SwigValueWrapper<wxImage > result;
19525 void *argp1 = 0 ;
19526 int res1 = 0 ;
19527 double val2 ;
19528 int ecode2 = 0 ;
19529 double val3 ;
19530 int ecode3 = 0 ;
19531 double val4 ;
19532 int ecode4 = 0 ;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 PyObject * obj2 = 0 ;
19536 PyObject * obj3 = 0 ;
19537 char * kwnames[] = {
19538 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19539 };
19540
19541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19543 if (!SWIG_IsOK(res1)) {
19544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19545 }
19546 arg1 = reinterpret_cast< wxImage * >(argp1);
19547 if (obj1) {
19548 ecode2 = SWIG_AsVal_double(obj1, &val2);
19549 if (!SWIG_IsOK(ecode2)) {
19550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19551 }
19552 arg2 = static_cast< double >(val2);
19553 }
19554 if (obj2) {
19555 ecode3 = SWIG_AsVal_double(obj2, &val3);
19556 if (!SWIG_IsOK(ecode3)) {
19557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19558 }
19559 arg3 = static_cast< double >(val3);
19560 }
19561 if (obj3) {
19562 ecode4 = SWIG_AsVal_double(obj3, &val4);
19563 if (!SWIG_IsOK(ecode4)) {
19564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19565 }
19566 arg4 = static_cast< double >(val4);
19567 }
19568 {
19569 PyThreadState* __tstate = wxPyBeginAllowThreads();
19570 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19571 wxPyEndAllowThreads(__tstate);
19572 if (PyErr_Occurred()) SWIG_fail;
19573 }
19574 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19575 return resultobj;
19576 fail:
19577 return NULL;
19578 }
19579
19580
19581 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj = 0;
19583 wxImage *arg1 = (wxImage *) 0 ;
19584 byte arg2 ;
19585 byte arg3 ;
19586 byte arg4 ;
19587 SwigValueWrapper<wxImage > result;
19588 void *argp1 = 0 ;
19589 int res1 = 0 ;
19590 unsigned char val2 ;
19591 int ecode2 = 0 ;
19592 unsigned char val3 ;
19593 int ecode3 = 0 ;
19594 unsigned char val4 ;
19595 int ecode4 = 0 ;
19596 PyObject * obj0 = 0 ;
19597 PyObject * obj1 = 0 ;
19598 PyObject * obj2 = 0 ;
19599 PyObject * obj3 = 0 ;
19600 char * kwnames[] = {
19601 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19602 };
19603
19604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19606 if (!SWIG_IsOK(res1)) {
19607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19608 }
19609 arg1 = reinterpret_cast< wxImage * >(argp1);
19610 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19611 if (!SWIG_IsOK(ecode2)) {
19612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19613 }
19614 arg2 = static_cast< byte >(val2);
19615 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19616 if (!SWIG_IsOK(ecode3)) {
19617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19618 }
19619 arg3 = static_cast< byte >(val3);
19620 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19621 if (!SWIG_IsOK(ecode4)) {
19622 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19623 }
19624 arg4 = static_cast< byte >(val4);
19625 {
19626 PyThreadState* __tstate = wxPyBeginAllowThreads();
19627 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19628 wxPyEndAllowThreads(__tstate);
19629 if (PyErr_Occurred()) SWIG_fail;
19630 }
19631 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19632 return resultobj;
19633 fail:
19634 return NULL;
19635 }
19636
19637
19638 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19639 PyObject *resultobj = 0;
19640 wxImage *arg1 = (wxImage *) 0 ;
19641 wxString *arg2 = 0 ;
19642 wxString *arg3 = 0 ;
19643 void *argp1 = 0 ;
19644 int res1 = 0 ;
19645 bool temp2 = false ;
19646 bool temp3 = false ;
19647 PyObject * obj0 = 0 ;
19648 PyObject * obj1 = 0 ;
19649 PyObject * obj2 = 0 ;
19650 char * kwnames[] = {
19651 (char *) "self",(char *) "name",(char *) "value", NULL
19652 };
19653
19654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19656 if (!SWIG_IsOK(res1)) {
19657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19658 }
19659 arg1 = reinterpret_cast< wxImage * >(argp1);
19660 {
19661 arg2 = wxString_in_helper(obj1);
19662 if (arg2 == NULL) SWIG_fail;
19663 temp2 = true;
19664 }
19665 {
19666 arg3 = wxString_in_helper(obj2);
19667 if (arg3 == NULL) SWIG_fail;
19668 temp3 = true;
19669 }
19670 {
19671 PyThreadState* __tstate = wxPyBeginAllowThreads();
19672 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19673 wxPyEndAllowThreads(__tstate);
19674 if (PyErr_Occurred()) SWIG_fail;
19675 }
19676 resultobj = SWIG_Py_Void();
19677 {
19678 if (temp2)
19679 delete arg2;
19680 }
19681 {
19682 if (temp3)
19683 delete arg3;
19684 }
19685 return resultobj;
19686 fail:
19687 {
19688 if (temp2)
19689 delete arg2;
19690 }
19691 {
19692 if (temp3)
19693 delete arg3;
19694 }
19695 return NULL;
19696 }
19697
19698
19699 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19700 PyObject *resultobj = 0;
19701 wxImage *arg1 = (wxImage *) 0 ;
19702 wxString *arg2 = 0 ;
19703 int arg3 ;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 bool temp2 = false ;
19707 int val3 ;
19708 int ecode3 = 0 ;
19709 PyObject * obj0 = 0 ;
19710 PyObject * obj1 = 0 ;
19711 PyObject * obj2 = 0 ;
19712 char * kwnames[] = {
19713 (char *) "self",(char *) "name",(char *) "value", NULL
19714 };
19715
19716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19718 if (!SWIG_IsOK(res1)) {
19719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19720 }
19721 arg1 = reinterpret_cast< wxImage * >(argp1);
19722 {
19723 arg2 = wxString_in_helper(obj1);
19724 if (arg2 == NULL) SWIG_fail;
19725 temp2 = true;
19726 }
19727 ecode3 = SWIG_AsVal_int(obj2, &val3);
19728 if (!SWIG_IsOK(ecode3)) {
19729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19730 }
19731 arg3 = static_cast< int >(val3);
19732 {
19733 PyThreadState* __tstate = wxPyBeginAllowThreads();
19734 (arg1)->SetOption((wxString const &)*arg2,arg3);
19735 wxPyEndAllowThreads(__tstate);
19736 if (PyErr_Occurred()) SWIG_fail;
19737 }
19738 resultobj = SWIG_Py_Void();
19739 {
19740 if (temp2)
19741 delete arg2;
19742 }
19743 return resultobj;
19744 fail:
19745 {
19746 if (temp2)
19747 delete arg2;
19748 }
19749 return NULL;
19750 }
19751
19752
19753 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj = 0;
19755 wxImage *arg1 = (wxImage *) 0 ;
19756 wxString *arg2 = 0 ;
19757 wxString result;
19758 void *argp1 = 0 ;
19759 int res1 = 0 ;
19760 bool temp2 = false ;
19761 PyObject * obj0 = 0 ;
19762 PyObject * obj1 = 0 ;
19763 char * kwnames[] = {
19764 (char *) "self",(char *) "name", NULL
19765 };
19766
19767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19769 if (!SWIG_IsOK(res1)) {
19770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19771 }
19772 arg1 = reinterpret_cast< wxImage * >(argp1);
19773 {
19774 arg2 = wxString_in_helper(obj1);
19775 if (arg2 == NULL) SWIG_fail;
19776 temp2 = true;
19777 }
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19781 wxPyEndAllowThreads(__tstate);
19782 if (PyErr_Occurred()) SWIG_fail;
19783 }
19784 {
19785 #if wxUSE_UNICODE
19786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19787 #else
19788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19789 #endif
19790 }
19791 {
19792 if (temp2)
19793 delete arg2;
19794 }
19795 return resultobj;
19796 fail:
19797 {
19798 if (temp2)
19799 delete arg2;
19800 }
19801 return NULL;
19802 }
19803
19804
19805 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19806 PyObject *resultobj = 0;
19807 wxImage *arg1 = (wxImage *) 0 ;
19808 wxString *arg2 = 0 ;
19809 int result;
19810 void *argp1 = 0 ;
19811 int res1 = 0 ;
19812 bool temp2 = false ;
19813 PyObject * obj0 = 0 ;
19814 PyObject * obj1 = 0 ;
19815 char * kwnames[] = {
19816 (char *) "self",(char *) "name", NULL
19817 };
19818
19819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19821 if (!SWIG_IsOK(res1)) {
19822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19823 }
19824 arg1 = reinterpret_cast< wxImage * >(argp1);
19825 {
19826 arg2 = wxString_in_helper(obj1);
19827 if (arg2 == NULL) SWIG_fail;
19828 temp2 = true;
19829 }
19830 {
19831 PyThreadState* __tstate = wxPyBeginAllowThreads();
19832 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19833 wxPyEndAllowThreads(__tstate);
19834 if (PyErr_Occurred()) SWIG_fail;
19835 }
19836 resultobj = SWIG_From_int(static_cast< int >(result));
19837 {
19838 if (temp2)
19839 delete arg2;
19840 }
19841 return resultobj;
19842 fail:
19843 {
19844 if (temp2)
19845 delete arg2;
19846 }
19847 return NULL;
19848 }
19849
19850
19851 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj = 0;
19853 wxImage *arg1 = (wxImage *) 0 ;
19854 wxString *arg2 = 0 ;
19855 bool result;
19856 void *argp1 = 0 ;
19857 int res1 = 0 ;
19858 bool temp2 = false ;
19859 PyObject * obj0 = 0 ;
19860 PyObject * obj1 = 0 ;
19861 char * kwnames[] = {
19862 (char *) "self",(char *) "name", NULL
19863 };
19864
19865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19867 if (!SWIG_IsOK(res1)) {
19868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19869 }
19870 arg1 = reinterpret_cast< wxImage * >(argp1);
19871 {
19872 arg2 = wxString_in_helper(obj1);
19873 if (arg2 == NULL) SWIG_fail;
19874 temp2 = true;
19875 }
19876 {
19877 PyThreadState* __tstate = wxPyBeginAllowThreads();
19878 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19879 wxPyEndAllowThreads(__tstate);
19880 if (PyErr_Occurred()) SWIG_fail;
19881 }
19882 {
19883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19884 }
19885 {
19886 if (temp2)
19887 delete arg2;
19888 }
19889 return resultobj;
19890 fail:
19891 {
19892 if (temp2)
19893 delete arg2;
19894 }
19895 return NULL;
19896 }
19897
19898
19899 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19900 PyObject *resultobj = 0;
19901 wxImage *arg1 = (wxImage *) 0 ;
19902 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19903 unsigned long result;
19904 void *argp1 = 0 ;
19905 int res1 = 0 ;
19906 unsigned long val2 ;
19907 int ecode2 = 0 ;
19908 PyObject * obj0 = 0 ;
19909 PyObject * obj1 = 0 ;
19910 char * kwnames[] = {
19911 (char *) "self",(char *) "stopafter", NULL
19912 };
19913
19914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19916 if (!SWIG_IsOK(res1)) {
19917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19918 }
19919 arg1 = reinterpret_cast< wxImage * >(argp1);
19920 if (obj1) {
19921 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19922 if (!SWIG_IsOK(ecode2)) {
19923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19924 }
19925 arg2 = static_cast< unsigned long >(val2);
19926 }
19927 {
19928 PyThreadState* __tstate = wxPyBeginAllowThreads();
19929 result = (unsigned long)(arg1)->CountColours(arg2);
19930 wxPyEndAllowThreads(__tstate);
19931 if (PyErr_Occurred()) SWIG_fail;
19932 }
19933 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19934 return resultobj;
19935 fail:
19936 return NULL;
19937 }
19938
19939
19940 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19941 PyObject *resultobj = 0;
19942 wxImage *arg1 = (wxImage *) 0 ;
19943 wxImageHistogram *arg2 = 0 ;
19944 unsigned long result;
19945 void *argp1 = 0 ;
19946 int res1 = 0 ;
19947 void *argp2 = 0 ;
19948 int res2 = 0 ;
19949 PyObject * obj0 = 0 ;
19950 PyObject * obj1 = 0 ;
19951 char * kwnames[] = {
19952 (char *) "self",(char *) "h", NULL
19953 };
19954
19955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19957 if (!SWIG_IsOK(res1)) {
19958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19959 }
19960 arg1 = reinterpret_cast< wxImage * >(argp1);
19961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19962 if (!SWIG_IsOK(res2)) {
19963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19964 }
19965 if (!argp2) {
19966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19967 }
19968 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19972 wxPyEndAllowThreads(__tstate);
19973 if (PyErr_Occurred()) SWIG_fail;
19974 }
19975 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19976 return resultobj;
19977 fail:
19978 return NULL;
19979 }
19980
19981
19982 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19983 PyObject *resultobj = 0;
19984 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19985 void *argp1 = 0 ;
19986 int res1 = 0 ;
19987 PyObject * obj0 = 0 ;
19988 char * kwnames[] = {
19989 (char *) "handler", NULL
19990 };
19991
19992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19994 if (!SWIG_IsOK(res1)) {
19995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19996 }
19997 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19998 {
19999 PyThreadState* __tstate = wxPyBeginAllowThreads();
20000 wxImage::AddHandler(arg1);
20001 wxPyEndAllowThreads(__tstate);
20002 if (PyErr_Occurred()) SWIG_fail;
20003 }
20004 resultobj = SWIG_Py_Void();
20005 return resultobj;
20006 fail:
20007 return NULL;
20008 }
20009
20010
20011 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20012 PyObject *resultobj = 0;
20013 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
20014 void *argp1 = 0 ;
20015 int res1 = 0 ;
20016 PyObject * obj0 = 0 ;
20017 char * kwnames[] = {
20018 (char *) "handler", NULL
20019 };
20020
20021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
20022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
20023 if (!SWIG_IsOK(res1)) {
20024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
20025 }
20026 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 wxImage::InsertHandler(arg1);
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 resultobj = SWIG_Py_Void();
20034 return resultobj;
20035 fail:
20036 return NULL;
20037 }
20038
20039
20040 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20041 PyObject *resultobj = 0;
20042 wxString *arg1 = 0 ;
20043 bool result;
20044 bool temp1 = false ;
20045 PyObject * obj0 = 0 ;
20046 char * kwnames[] = {
20047 (char *) "name", NULL
20048 };
20049
20050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
20051 {
20052 arg1 = wxString_in_helper(obj0);
20053 if (arg1 == NULL) SWIG_fail;
20054 temp1 = true;
20055 }
20056 {
20057 PyThreadState* __tstate = wxPyBeginAllowThreads();
20058 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
20059 wxPyEndAllowThreads(__tstate);
20060 if (PyErr_Occurred()) SWIG_fail;
20061 }
20062 {
20063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20064 }
20065 {
20066 if (temp1)
20067 delete arg1;
20068 }
20069 return resultobj;
20070 fail:
20071 {
20072 if (temp1)
20073 delete arg1;
20074 }
20075 return NULL;
20076 }
20077
20078
20079 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20080 PyObject *resultobj = 0;
20081 PyObject *result = 0 ;
20082
20083 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
20084 {
20085 PyThreadState* __tstate = wxPyBeginAllowThreads();
20086 result = (PyObject *)wxImage_GetHandlers();
20087 wxPyEndAllowThreads(__tstate);
20088 if (PyErr_Occurred()) SWIG_fail;
20089 }
20090 resultobj = result;
20091 return resultobj;
20092 fail:
20093 return NULL;
20094 }
20095
20096
20097 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20098 PyObject *resultobj = 0;
20099 wxString result;
20100
20101 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 result = wxImage::GetImageExtWildcard();
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 {
20109 #if wxUSE_UNICODE
20110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20111 #else
20112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20113 #endif
20114 }
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20122 PyObject *resultobj = 0;
20123 wxImage *arg1 = (wxImage *) 0 ;
20124 int arg2 = (int) -1 ;
20125 wxBitmap result;
20126 void *argp1 = 0 ;
20127 int res1 = 0 ;
20128 int val2 ;
20129 int ecode2 = 0 ;
20130 PyObject * obj0 = 0 ;
20131 PyObject * obj1 = 0 ;
20132 char * kwnames[] = {
20133 (char *) "self",(char *) "depth", NULL
20134 };
20135
20136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
20137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20138 if (!SWIG_IsOK(res1)) {
20139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20140 }
20141 arg1 = reinterpret_cast< wxImage * >(argp1);
20142 if (obj1) {
20143 ecode2 = SWIG_AsVal_int(obj1, &val2);
20144 if (!SWIG_IsOK(ecode2)) {
20145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
20146 }
20147 arg2 = static_cast< int >(val2);
20148 }
20149 {
20150 if (!wxPyCheckForApp()) SWIG_fail;
20151 PyThreadState* __tstate = wxPyBeginAllowThreads();
20152 result = wxImage_ConvertToBitmap(arg1,arg2);
20153 wxPyEndAllowThreads(__tstate);
20154 if (PyErr_Occurred()) SWIG_fail;
20155 }
20156 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20157 return resultobj;
20158 fail:
20159 return NULL;
20160 }
20161
20162
20163 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20164 PyObject *resultobj = 0;
20165 wxImage *arg1 = (wxImage *) 0 ;
20166 byte arg2 ;
20167 byte arg3 ;
20168 byte arg4 ;
20169 wxBitmap result;
20170 void *argp1 = 0 ;
20171 int res1 = 0 ;
20172 unsigned char val2 ;
20173 int ecode2 = 0 ;
20174 unsigned char val3 ;
20175 int ecode3 = 0 ;
20176 unsigned char val4 ;
20177 int ecode4 = 0 ;
20178 PyObject * obj0 = 0 ;
20179 PyObject * obj1 = 0 ;
20180 PyObject * obj2 = 0 ;
20181 PyObject * obj3 = 0 ;
20182 char * kwnames[] = {
20183 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
20184 };
20185
20186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20188 if (!SWIG_IsOK(res1)) {
20189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20190 }
20191 arg1 = reinterpret_cast< wxImage * >(argp1);
20192 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
20193 if (!SWIG_IsOK(ecode2)) {
20194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
20195 }
20196 arg2 = static_cast< byte >(val2);
20197 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
20198 if (!SWIG_IsOK(ecode3)) {
20199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
20200 }
20201 arg3 = static_cast< byte >(val3);
20202 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
20203 if (!SWIG_IsOK(ecode4)) {
20204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
20205 }
20206 arg4 = static_cast< byte >(val4);
20207 {
20208 if (!wxPyCheckForApp()) SWIG_fail;
20209 PyThreadState* __tstate = wxPyBeginAllowThreads();
20210 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20222 PyObject *resultobj = 0;
20223 wxImage *arg1 = (wxImage *) 0 ;
20224 double arg2 ;
20225 void *argp1 = 0 ;
20226 int res1 = 0 ;
20227 double val2 ;
20228 int ecode2 = 0 ;
20229 PyObject * obj0 = 0 ;
20230 PyObject * obj1 = 0 ;
20231 char * kwnames[] = {
20232 (char *) "self",(char *) "angle", NULL
20233 };
20234
20235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
20236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20237 if (!SWIG_IsOK(res1)) {
20238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
20239 }
20240 arg1 = reinterpret_cast< wxImage * >(argp1);
20241 ecode2 = SWIG_AsVal_double(obj1, &val2);
20242 if (!SWIG_IsOK(ecode2)) {
20243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
20244 }
20245 arg2 = static_cast< double >(val2);
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 (arg1)->RotateHue(arg2);
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 resultobj = SWIG_Py_Void();
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20260 PyObject *resultobj = 0;
20261 wxImage_RGBValue arg1 ;
20262 wxImage_HSVValue result;
20263 void *argp1 ;
20264 int res1 = 0 ;
20265 PyObject * obj0 = 0 ;
20266 char * kwnames[] = {
20267 (char *) "rgb", NULL
20268 };
20269
20270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
20271 {
20272 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
20273 if (!SWIG_IsOK(res1)) {
20274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20275 }
20276 if (!argp1) {
20277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20278 } else {
20279 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
20280 arg1 = *temp;
20281 if (SWIG_IsNewObj(res1)) delete temp;
20282 }
20283 }
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = wxImage::RGBtoHSV(arg1);
20287 wxPyEndAllowThreads(__tstate);
20288 if (PyErr_Occurred()) SWIG_fail;
20289 }
20290 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20298 PyObject *resultobj = 0;
20299 wxImage_HSVValue arg1 ;
20300 wxImage_RGBValue result;
20301 void *argp1 ;
20302 int res1 = 0 ;
20303 PyObject * obj0 = 0 ;
20304 char * kwnames[] = {
20305 (char *) "hsv", NULL
20306 };
20307
20308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
20309 {
20310 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
20311 if (!SWIG_IsOK(res1)) {
20312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20313 }
20314 if (!argp1) {
20315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20316 } else {
20317 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
20318 arg1 = *temp;
20319 if (SWIG_IsNewObj(res1)) delete temp;
20320 }
20321 }
20322 {
20323 PyThreadState* __tstate = wxPyBeginAllowThreads();
20324 result = wxImage::HSVtoRGB(arg1);
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
20329 return resultobj;
20330 fail:
20331 return NULL;
20332 }
20333
20334
20335 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20336 PyObject *obj;
20337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20338 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
20339 return SWIG_Py_Void();
20340 }
20341
20342 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20343 return SWIG_Python_InitShadowInstance(args);
20344 }
20345
20346 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20347 PyObject *resultobj = 0;
20348 int arg1 ;
20349 int arg2 ;
20350 buffer arg3 ;
20351 int arg4 ;
20352 buffer arg5 = (buffer) NULL ;
20353 int arg6 = (int) 0 ;
20354 wxImage *result = 0 ;
20355 int val1 ;
20356 int ecode1 = 0 ;
20357 int val2 ;
20358 int ecode2 = 0 ;
20359 Py_ssize_t temp3 ;
20360 Py_ssize_t temp5 ;
20361 PyObject * obj0 = 0 ;
20362 PyObject * obj1 = 0 ;
20363 PyObject * obj2 = 0 ;
20364 PyObject * obj3 = 0 ;
20365 char * kwnames[] = {
20366 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
20367 };
20368
20369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20370 ecode1 = SWIG_AsVal_int(obj0, &val1);
20371 if (!SWIG_IsOK(ecode1)) {
20372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
20373 }
20374 arg1 = static_cast< int >(val1);
20375 ecode2 = SWIG_AsVal_int(obj1, &val2);
20376 if (!SWIG_IsOK(ecode2)) {
20377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
20378 }
20379 arg2 = static_cast< int >(val2);
20380 {
20381 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
20382 arg4 = (int)temp3;
20383 }
20384 if (obj3) {
20385 {
20386 if (obj3 != Py_None) {
20387 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
20388 arg6 = (int)temp5;
20389 }
20390 }
20391 }
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
20395 wxPyEndAllowThreads(__tstate);
20396 if (PyErr_Occurred()) SWIG_fail;
20397 }
20398 {
20399 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
20400 }
20401 return resultobj;
20402 fail:
20403 return NULL;
20404 }
20405
20406
20407 SWIGINTERN int NullImage_set(PyObject *) {
20408 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
20409 return 1;
20410 }
20411
20412
20413 SWIGINTERN PyObject *NullImage_get(void) {
20414 PyObject *pyobj = 0;
20415
20416 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
20417 return pyobj;
20418 }
20419
20420
20421 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
20422 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
20423 return 1;
20424 }
20425
20426
20427 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
20428 PyObject *pyobj = 0;
20429
20430 {
20431 #if wxUSE_UNICODE
20432 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20433 #else
20434 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20435 #endif
20436 }
20437 return pyobj;
20438 }
20439
20440
20441 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
20442 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
20443 return 1;
20444 }
20445
20446
20447 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
20448 PyObject *pyobj = 0;
20449
20450 {
20451 #if wxUSE_UNICODE
20452 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20453 #else
20454 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20455 #endif
20456 }
20457 return pyobj;
20458 }
20459
20460
20461 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
20462 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
20463 return 1;
20464 }
20465
20466
20467 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
20468 PyObject *pyobj = 0;
20469
20470 {
20471 #if wxUSE_UNICODE
20472 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20473 #else
20474 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20475 #endif
20476 }
20477 return pyobj;
20478 }
20479
20480
20481 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
20482 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
20483 return 1;
20484 }
20485
20486
20487 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
20488 PyObject *pyobj = 0;
20489
20490 {
20491 #if wxUSE_UNICODE
20492 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20493 #else
20494 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20495 #endif
20496 }
20497 return pyobj;
20498 }
20499
20500
20501 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
20502 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
20503 return 1;
20504 }
20505
20506
20507 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
20508 PyObject *pyobj = 0;
20509
20510 {
20511 #if wxUSE_UNICODE
20512 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20513 #else
20514 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20515 #endif
20516 }
20517 return pyobj;
20518 }
20519
20520
20521 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
20522 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
20523 return 1;
20524 }
20525
20526
20527 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
20528 PyObject *pyobj = 0;
20529
20530 {
20531 #if wxUSE_UNICODE
20532 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20533 #else
20534 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20535 #endif
20536 }
20537 return pyobj;
20538 }
20539
20540
20541 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20542 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20543 return 1;
20544 }
20545
20546
20547 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20548 PyObject *pyobj = 0;
20549
20550 {
20551 #if wxUSE_UNICODE
20552 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20553 #else
20554 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20555 #endif
20556 }
20557 return pyobj;
20558 }
20559
20560
20561 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20562 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20563 return 1;
20564 }
20565
20566
20567 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20568 PyObject *pyobj = 0;
20569
20570 {
20571 #if wxUSE_UNICODE
20572 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20573 #else
20574 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20575 #endif
20576 }
20577 return pyobj;
20578 }
20579
20580
20581 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20582 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20583 return 1;
20584 }
20585
20586
20587 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20588 PyObject *pyobj = 0;
20589
20590 {
20591 #if wxUSE_UNICODE
20592 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20593 #else
20594 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20595 #endif
20596 }
20597 return pyobj;
20598 }
20599
20600
20601 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20602 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20603 return 1;
20604 }
20605
20606
20607 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20608 PyObject *pyobj = 0;
20609
20610 {
20611 #if wxUSE_UNICODE
20612 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20613 #else
20614 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20615 #endif
20616 }
20617 return pyobj;
20618 }
20619
20620
20621 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20622 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20623 return 1;
20624 }
20625
20626
20627 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20628 PyObject *pyobj = 0;
20629
20630 {
20631 #if wxUSE_UNICODE
20632 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20633 #else
20634 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20635 #endif
20636 }
20637 return pyobj;
20638 }
20639
20640
20641 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20642 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20643 return 1;
20644 }
20645
20646
20647 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20648 PyObject *pyobj = 0;
20649
20650 {
20651 #if wxUSE_UNICODE
20652 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20653 #else
20654 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20655 #endif
20656 }
20657 return pyobj;
20658 }
20659
20660
20661 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20662 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20663 return 1;
20664 }
20665
20666
20667 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20668 PyObject *pyobj = 0;
20669
20670 {
20671 #if wxUSE_UNICODE
20672 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20673 #else
20674 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20675 #endif
20676 }
20677 return pyobj;
20678 }
20679
20680
20681 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20682 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20683 return 1;
20684 }
20685
20686
20687 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20688 PyObject *pyobj = 0;
20689
20690 {
20691 #if wxUSE_UNICODE
20692 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20693 #else
20694 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20695 #endif
20696 }
20697 return pyobj;
20698 }
20699
20700
20701 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20702 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20703 return 1;
20704 }
20705
20706
20707 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20708 PyObject *pyobj = 0;
20709
20710 {
20711 #if wxUSE_UNICODE
20712 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20713 #else
20714 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20715 #endif
20716 }
20717 return pyobj;
20718 }
20719
20720
20721 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20722 PyObject *resultobj = 0;
20723 wxBMPHandler *result = 0 ;
20724
20725 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20726 {
20727 PyThreadState* __tstate = wxPyBeginAllowThreads();
20728 result = (wxBMPHandler *)new wxBMPHandler();
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20733 return resultobj;
20734 fail:
20735 return NULL;
20736 }
20737
20738
20739 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20740 PyObject *obj;
20741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20742 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20743 return SWIG_Py_Void();
20744 }
20745
20746 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20747 return SWIG_Python_InitShadowInstance(args);
20748 }
20749
20750 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20751 PyObject *resultobj = 0;
20752 wxICOHandler *result = 0 ;
20753
20754 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20755 {
20756 PyThreadState* __tstate = wxPyBeginAllowThreads();
20757 result = (wxICOHandler *)new wxICOHandler();
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20762 return resultobj;
20763 fail:
20764 return NULL;
20765 }
20766
20767
20768 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20769 PyObject *obj;
20770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20771 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20772 return SWIG_Py_Void();
20773 }
20774
20775 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20776 return SWIG_Python_InitShadowInstance(args);
20777 }
20778
20779 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20780 PyObject *resultobj = 0;
20781 wxCURHandler *result = 0 ;
20782
20783 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20784 {
20785 PyThreadState* __tstate = wxPyBeginAllowThreads();
20786 result = (wxCURHandler *)new wxCURHandler();
20787 wxPyEndAllowThreads(__tstate);
20788 if (PyErr_Occurred()) SWIG_fail;
20789 }
20790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20791 return resultobj;
20792 fail:
20793 return NULL;
20794 }
20795
20796
20797 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20798 PyObject *obj;
20799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20800 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20801 return SWIG_Py_Void();
20802 }
20803
20804 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20805 return SWIG_Python_InitShadowInstance(args);
20806 }
20807
20808 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20809 PyObject *resultobj = 0;
20810 wxANIHandler *result = 0 ;
20811
20812 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (wxANIHandler *)new wxANIHandler();
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20827 PyObject *obj;
20828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20829 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20830 return SWIG_Py_Void();
20831 }
20832
20833 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20834 return SWIG_Python_InitShadowInstance(args);
20835 }
20836
20837 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20838 PyObject *resultobj = 0;
20839 wxPNGHandler *result = 0 ;
20840
20841 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20842 {
20843 PyThreadState* __tstate = wxPyBeginAllowThreads();
20844 result = (wxPNGHandler *)new wxPNGHandler();
20845 wxPyEndAllowThreads(__tstate);
20846 if (PyErr_Occurred()) SWIG_fail;
20847 }
20848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20849 return resultobj;
20850 fail:
20851 return NULL;
20852 }
20853
20854
20855 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20856 PyObject *obj;
20857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20858 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20859 return SWIG_Py_Void();
20860 }
20861
20862 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20863 return SWIG_Python_InitShadowInstance(args);
20864 }
20865
20866 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20867 PyObject *resultobj = 0;
20868 wxGIFHandler *result = 0 ;
20869
20870 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 result = (wxGIFHandler *)new wxGIFHandler();
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20885 PyObject *obj;
20886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20887 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20888 return SWIG_Py_Void();
20889 }
20890
20891 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20892 return SWIG_Python_InitShadowInstance(args);
20893 }
20894
20895 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20896 PyObject *resultobj = 0;
20897 wxPCXHandler *result = 0 ;
20898
20899 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20900 {
20901 PyThreadState* __tstate = wxPyBeginAllowThreads();
20902 result = (wxPCXHandler *)new wxPCXHandler();
20903 wxPyEndAllowThreads(__tstate);
20904 if (PyErr_Occurred()) SWIG_fail;
20905 }
20906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20907 return resultobj;
20908 fail:
20909 return NULL;
20910 }
20911
20912
20913 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20914 PyObject *obj;
20915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20916 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20917 return SWIG_Py_Void();
20918 }
20919
20920 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20921 return SWIG_Python_InitShadowInstance(args);
20922 }
20923
20924 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20925 PyObject *resultobj = 0;
20926 wxJPEGHandler *result = 0 ;
20927
20928 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 result = (wxJPEGHandler *)new wxJPEGHandler();
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *obj;
20944 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20945 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20946 return SWIG_Py_Void();
20947 }
20948
20949 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20950 return SWIG_Python_InitShadowInstance(args);
20951 }
20952
20953 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20954 PyObject *resultobj = 0;
20955 wxPNMHandler *result = 0 ;
20956
20957 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20958 {
20959 PyThreadState* __tstate = wxPyBeginAllowThreads();
20960 result = (wxPNMHandler *)new wxPNMHandler();
20961 wxPyEndAllowThreads(__tstate);
20962 if (PyErr_Occurred()) SWIG_fail;
20963 }
20964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20965 return resultobj;
20966 fail:
20967 return NULL;
20968 }
20969
20970
20971 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20972 PyObject *obj;
20973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20974 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20975 return SWIG_Py_Void();
20976 }
20977
20978 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 return SWIG_Python_InitShadowInstance(args);
20980 }
20981
20982 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20983 PyObject *resultobj = 0;
20984 wxXPMHandler *result = 0 ;
20985
20986 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 result = (wxXPMHandler *)new wxXPMHandler();
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21001 PyObject *obj;
21002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21003 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
21004 return SWIG_Py_Void();
21005 }
21006
21007 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21008 return SWIG_Python_InitShadowInstance(args);
21009 }
21010
21011 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21012 PyObject *resultobj = 0;
21013 wxTIFFHandler *result = 0 ;
21014
21015 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
21016 {
21017 PyThreadState* __tstate = wxPyBeginAllowThreads();
21018 result = (wxTIFFHandler *)new wxTIFFHandler();
21019 wxPyEndAllowThreads(__tstate);
21020 if (PyErr_Occurred()) SWIG_fail;
21021 }
21022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *obj;
21031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21032 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
21033 return SWIG_Py_Void();
21034 }
21035
21036 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21037 return SWIG_Python_InitShadowInstance(args);
21038 }
21039
21040 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21041 PyObject *resultobj = 0;
21042 wxTGAHandler *result = 0 ;
21043
21044 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (wxTGAHandler *)new wxTGAHandler();
21048 wxPyEndAllowThreads(__tstate);
21049 if (PyErr_Occurred()) SWIG_fail;
21050 }
21051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21059 PyObject *obj;
21060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21061 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
21062 return SWIG_Py_Void();
21063 }
21064
21065 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21066 return SWIG_Python_InitShadowInstance(args);
21067 }
21068
21069 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21070 PyObject *resultobj = 0;
21071 wxImage *arg1 = 0 ;
21072 wxImage *arg2 = 0 ;
21073 int arg3 = (int) 236 ;
21074 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
21075 bool result;
21076 void *argp1 = 0 ;
21077 int res1 = 0 ;
21078 void *argp2 = 0 ;
21079 int res2 = 0 ;
21080 int val3 ;
21081 int ecode3 = 0 ;
21082 int val4 ;
21083 int ecode4 = 0 ;
21084 PyObject * obj0 = 0 ;
21085 PyObject * obj1 = 0 ;
21086 PyObject * obj2 = 0 ;
21087 PyObject * obj3 = 0 ;
21088 char * kwnames[] = {
21089 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
21090 };
21091
21092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21093 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
21094 if (!SWIG_IsOK(res1)) {
21095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21096 }
21097 if (!argp1) {
21098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21099 }
21100 arg1 = reinterpret_cast< wxImage * >(argp1);
21101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
21102 if (!SWIG_IsOK(res2)) {
21103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21104 }
21105 if (!argp2) {
21106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21107 }
21108 arg2 = reinterpret_cast< wxImage * >(argp2);
21109 if (obj2) {
21110 ecode3 = SWIG_AsVal_int(obj2, &val3);
21111 if (!SWIG_IsOK(ecode3)) {
21112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
21113 }
21114 arg3 = static_cast< int >(val3);
21115 }
21116 if (obj3) {
21117 ecode4 = SWIG_AsVal_int(obj3, &val4);
21118 if (!SWIG_IsOK(ecode4)) {
21119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
21120 }
21121 arg4 = static_cast< int >(val4);
21122 }
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 {
21130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21131 }
21132 return resultobj;
21133 fail:
21134 return NULL;
21135 }
21136
21137
21138 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21139 PyObject *obj;
21140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21141 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
21142 return SWIG_Py_Void();
21143 }
21144
21145 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxEvtHandler *result = 0 ;
21148
21149 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 result = (wxEvtHandler *)new wxEvtHandler();
21153 wxPyEndAllowThreads(__tstate);
21154 if (PyErr_Occurred()) SWIG_fail;
21155 }
21156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
21157 return resultobj;
21158 fail:
21159 return NULL;
21160 }
21161
21162
21163 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21164 PyObject *resultobj = 0;
21165 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21166 wxEvtHandler *result = 0 ;
21167 void *argp1 = 0 ;
21168 int res1 = 0 ;
21169 PyObject *swig_obj[1] ;
21170
21171 if (!args) SWIG_fail;
21172 swig_obj[0] = args;
21173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21174 if (!SWIG_IsOK(res1)) {
21175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21176 }
21177 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21178 {
21179 PyThreadState* __tstate = wxPyBeginAllowThreads();
21180 result = (wxEvtHandler *)(arg1)->GetNextHandler();
21181 wxPyEndAllowThreads(__tstate);
21182 if (PyErr_Occurred()) SWIG_fail;
21183 }
21184 {
21185 resultobj = wxPyMake_wxObject(result, 0);
21186 }
21187 return resultobj;
21188 fail:
21189 return NULL;
21190 }
21191
21192
21193 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21194 PyObject *resultobj = 0;
21195 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21196 wxEvtHandler *result = 0 ;
21197 void *argp1 = 0 ;
21198 int res1 = 0 ;
21199 PyObject *swig_obj[1] ;
21200
21201 if (!args) SWIG_fail;
21202 swig_obj[0] = args;
21203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21204 if (!SWIG_IsOK(res1)) {
21205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21206 }
21207 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21208 {
21209 PyThreadState* __tstate = wxPyBeginAllowThreads();
21210 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
21211 wxPyEndAllowThreads(__tstate);
21212 if (PyErr_Occurred()) SWIG_fail;
21213 }
21214 {
21215 resultobj = wxPyMake_wxObject(result, 0);
21216 }
21217 return resultobj;
21218 fail:
21219 return NULL;
21220 }
21221
21222
21223 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21224 PyObject *resultobj = 0;
21225 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21226 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21227 void *argp1 = 0 ;
21228 int res1 = 0 ;
21229 void *argp2 = 0 ;
21230 int res2 = 0 ;
21231 PyObject * obj0 = 0 ;
21232 PyObject * obj1 = 0 ;
21233 char * kwnames[] = {
21234 (char *) "self",(char *) "handler", NULL
21235 };
21236
21237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21239 if (!SWIG_IsOK(res1)) {
21240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21241 }
21242 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21244 if (!SWIG_IsOK(res2)) {
21245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21246 }
21247 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21248 {
21249 PyThreadState* __tstate = wxPyBeginAllowThreads();
21250 (arg1)->SetNextHandler(arg2);
21251 wxPyEndAllowThreads(__tstate);
21252 if (PyErr_Occurred()) SWIG_fail;
21253 }
21254 resultobj = SWIG_Py_Void();
21255 return resultobj;
21256 fail:
21257 return NULL;
21258 }
21259
21260
21261 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21262 PyObject *resultobj = 0;
21263 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21264 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21265 void *argp1 = 0 ;
21266 int res1 = 0 ;
21267 void *argp2 = 0 ;
21268 int res2 = 0 ;
21269 PyObject * obj0 = 0 ;
21270 PyObject * obj1 = 0 ;
21271 char * kwnames[] = {
21272 (char *) "self",(char *) "handler", NULL
21273 };
21274
21275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21277 if (!SWIG_IsOK(res1)) {
21278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21279 }
21280 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21282 if (!SWIG_IsOK(res2)) {
21283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21284 }
21285 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21286 {
21287 PyThreadState* __tstate = wxPyBeginAllowThreads();
21288 (arg1)->SetPreviousHandler(arg2);
21289 wxPyEndAllowThreads(__tstate);
21290 if (PyErr_Occurred()) SWIG_fail;
21291 }
21292 resultobj = SWIG_Py_Void();
21293 return resultobj;
21294 fail:
21295 return NULL;
21296 }
21297
21298
21299 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21300 PyObject *resultobj = 0;
21301 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21302 bool result;
21303 void *argp1 = 0 ;
21304 int res1 = 0 ;
21305 PyObject *swig_obj[1] ;
21306
21307 if (!args) SWIG_fail;
21308 swig_obj[0] = args;
21309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21310 if (!SWIG_IsOK(res1)) {
21311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21312 }
21313 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21314 {
21315 PyThreadState* __tstate = wxPyBeginAllowThreads();
21316 result = (bool)(arg1)->GetEvtHandlerEnabled();
21317 wxPyEndAllowThreads(__tstate);
21318 if (PyErr_Occurred()) SWIG_fail;
21319 }
21320 {
21321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21322 }
21323 return resultobj;
21324 fail:
21325 return NULL;
21326 }
21327
21328
21329 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21330 PyObject *resultobj = 0;
21331 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21332 bool arg2 ;
21333 void *argp1 = 0 ;
21334 int res1 = 0 ;
21335 bool val2 ;
21336 int ecode2 = 0 ;
21337 PyObject * obj0 = 0 ;
21338 PyObject * obj1 = 0 ;
21339 char * kwnames[] = {
21340 (char *) "self",(char *) "enabled", NULL
21341 };
21342
21343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
21344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21345 if (!SWIG_IsOK(res1)) {
21346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21347 }
21348 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21349 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21350 if (!SWIG_IsOK(ecode2)) {
21351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
21352 }
21353 arg2 = static_cast< bool >(val2);
21354 {
21355 PyThreadState* __tstate = wxPyBeginAllowThreads();
21356 (arg1)->SetEvtHandlerEnabled(arg2);
21357 wxPyEndAllowThreads(__tstate);
21358 if (PyErr_Occurred()) SWIG_fail;
21359 }
21360 resultobj = SWIG_Py_Void();
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj = 0;
21369 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21370 wxEvent *arg2 = 0 ;
21371 bool result;
21372 void *argp1 = 0 ;
21373 int res1 = 0 ;
21374 void *argp2 = 0 ;
21375 int res2 = 0 ;
21376 PyObject * obj0 = 0 ;
21377 PyObject * obj1 = 0 ;
21378 char * kwnames[] = {
21379 (char *) "self",(char *) "event", NULL
21380 };
21381
21382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21384 if (!SWIG_IsOK(res1)) {
21385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21386 }
21387 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21388 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21389 if (!SWIG_IsOK(res2)) {
21390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21391 }
21392 if (!argp2) {
21393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21394 }
21395 arg2 = reinterpret_cast< wxEvent * >(argp2);
21396 {
21397 PyThreadState* __tstate = wxPyBeginAllowThreads();
21398 result = (bool)(arg1)->ProcessEvent(*arg2);
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 {
21403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21404 }
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj = 0;
21413 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21414 wxEvent *arg2 = 0 ;
21415 void *argp1 = 0 ;
21416 int res1 = 0 ;
21417 void *argp2 = 0 ;
21418 int res2 = 0 ;
21419 PyObject * obj0 = 0 ;
21420 PyObject * obj1 = 0 ;
21421 char * kwnames[] = {
21422 (char *) "self",(char *) "event", NULL
21423 };
21424
21425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21427 if (!SWIG_IsOK(res1)) {
21428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21429 }
21430 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21431 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21432 if (!SWIG_IsOK(res2)) {
21433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21434 }
21435 if (!argp2) {
21436 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21437 }
21438 arg2 = reinterpret_cast< wxEvent * >(argp2);
21439 {
21440 PyThreadState* __tstate = wxPyBeginAllowThreads();
21441 (arg1)->AddPendingEvent(*arg2);
21442 wxPyEndAllowThreads(__tstate);
21443 if (PyErr_Occurred()) SWIG_fail;
21444 }
21445 resultobj = SWIG_Py_Void();
21446 return resultobj;
21447 fail:
21448 return NULL;
21449 }
21450
21451
21452 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21453 PyObject *resultobj = 0;
21454 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21455 void *argp1 = 0 ;
21456 int res1 = 0 ;
21457 PyObject *swig_obj[1] ;
21458
21459 if (!args) SWIG_fail;
21460 swig_obj[0] = args;
21461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21462 if (!SWIG_IsOK(res1)) {
21463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21464 }
21465 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21466 {
21467 PyThreadState* __tstate = wxPyBeginAllowThreads();
21468 (arg1)->ProcessPendingEvents();
21469 wxPyEndAllowThreads(__tstate);
21470 if (PyErr_Occurred()) SWIG_fail;
21471 }
21472 resultobj = SWIG_Py_Void();
21473 return resultobj;
21474 fail:
21475 return NULL;
21476 }
21477
21478
21479 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21480 PyObject *resultobj = 0;
21481 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21482 int arg2 ;
21483 int arg3 ;
21484 int arg4 ;
21485 PyObject *arg5 = (PyObject *) 0 ;
21486 void *argp1 = 0 ;
21487 int res1 = 0 ;
21488 int val2 ;
21489 int ecode2 = 0 ;
21490 int val3 ;
21491 int ecode3 = 0 ;
21492 int val4 ;
21493 int ecode4 = 0 ;
21494 PyObject * obj0 = 0 ;
21495 PyObject * obj1 = 0 ;
21496 PyObject * obj2 = 0 ;
21497 PyObject * obj3 = 0 ;
21498 PyObject * obj4 = 0 ;
21499 char * kwnames[] = {
21500 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
21501 };
21502
21503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21505 if (!SWIG_IsOK(res1)) {
21506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21507 }
21508 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21509 ecode2 = SWIG_AsVal_int(obj1, &val2);
21510 if (!SWIG_IsOK(ecode2)) {
21511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
21512 }
21513 arg2 = static_cast< int >(val2);
21514 ecode3 = SWIG_AsVal_int(obj2, &val3);
21515 if (!SWIG_IsOK(ecode3)) {
21516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
21517 }
21518 arg3 = static_cast< int >(val3);
21519 ecode4 = SWIG_AsVal_int(obj3, &val4);
21520 if (!SWIG_IsOK(ecode4)) {
21521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21522 }
21523 arg4 = static_cast< int >(val4);
21524 arg5 = obj4;
21525 {
21526 PyThreadState* __tstate = wxPyBeginAllowThreads();
21527 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21528 wxPyEndAllowThreads(__tstate);
21529 if (PyErr_Occurred()) SWIG_fail;
21530 }
21531 resultobj = SWIG_Py_Void();
21532 return resultobj;
21533 fail:
21534 return NULL;
21535 }
21536
21537
21538 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21539 PyObject *resultobj = 0;
21540 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21541 int arg2 ;
21542 int arg3 = (int) -1 ;
21543 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21544 bool result;
21545 void *argp1 = 0 ;
21546 int res1 = 0 ;
21547 int val2 ;
21548 int ecode2 = 0 ;
21549 int val3 ;
21550 int ecode3 = 0 ;
21551 int val4 ;
21552 int ecode4 = 0 ;
21553 PyObject * obj0 = 0 ;
21554 PyObject * obj1 = 0 ;
21555 PyObject * obj2 = 0 ;
21556 PyObject * obj3 = 0 ;
21557 char * kwnames[] = {
21558 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21559 };
21560
21561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21563 if (!SWIG_IsOK(res1)) {
21564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21565 }
21566 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21567 ecode2 = SWIG_AsVal_int(obj1, &val2);
21568 if (!SWIG_IsOK(ecode2)) {
21569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21570 }
21571 arg2 = static_cast< int >(val2);
21572 if (obj2) {
21573 ecode3 = SWIG_AsVal_int(obj2, &val3);
21574 if (!SWIG_IsOK(ecode3)) {
21575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21576 }
21577 arg3 = static_cast< int >(val3);
21578 }
21579 if (obj3) {
21580 ecode4 = SWIG_AsVal_int(obj3, &val4);
21581 if (!SWIG_IsOK(ecode4)) {
21582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21583 }
21584 arg4 = static_cast< wxEventType >(val4);
21585 }
21586 {
21587 PyThreadState* __tstate = wxPyBeginAllowThreads();
21588 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21589 wxPyEndAllowThreads(__tstate);
21590 if (PyErr_Occurred()) SWIG_fail;
21591 }
21592 {
21593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21594 }
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21602 PyObject *resultobj = 0;
21603 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21604 PyObject *arg2 = (PyObject *) 0 ;
21605 bool arg3 = (bool) true ;
21606 void *argp1 = 0 ;
21607 int res1 = 0 ;
21608 bool val3 ;
21609 int ecode3 = 0 ;
21610 PyObject * obj0 = 0 ;
21611 PyObject * obj1 = 0 ;
21612 PyObject * obj2 = 0 ;
21613 char * kwnames[] = {
21614 (char *) "self",(char *) "_self",(char *) "incref", NULL
21615 };
21616
21617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21619 if (!SWIG_IsOK(res1)) {
21620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21621 }
21622 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21623 arg2 = obj1;
21624 if (obj2) {
21625 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21626 if (!SWIG_IsOK(ecode3)) {
21627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21628 }
21629 arg3 = static_cast< bool >(val3);
21630 }
21631 {
21632 PyThreadState* __tstate = wxPyBeginAllowThreads();
21633 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 resultobj = SWIG_Py_Void();
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21645 PyObject *obj;
21646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21647 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21648 return SWIG_Py_Void();
21649 }
21650
21651 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21652 return SWIG_Python_InitShadowInstance(args);
21653 }
21654
21655 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21656 PyObject *resultobj = 0;
21657 wxEventType result;
21658
21659 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21660 {
21661 PyThreadState* __tstate = wxPyBeginAllowThreads();
21662 result = (wxEventType)wxNewEventType();
21663 wxPyEndAllowThreads(__tstate);
21664 if (PyErr_Occurred()) SWIG_fail;
21665 }
21666 resultobj = SWIG_From_int(static_cast< int >(result));
21667 return resultobj;
21668 fail:
21669 return NULL;
21670 }
21671
21672
21673 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21674 PyObject *resultobj = 0;
21675 wxEvent *arg1 = (wxEvent *) 0 ;
21676 void *argp1 = 0 ;
21677 int res1 = 0 ;
21678 PyObject *swig_obj[1] ;
21679
21680 if (!args) SWIG_fail;
21681 swig_obj[0] = args;
21682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21683 if (!SWIG_IsOK(res1)) {
21684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21685 }
21686 arg1 = reinterpret_cast< wxEvent * >(argp1);
21687 {
21688 PyThreadState* __tstate = wxPyBeginAllowThreads();
21689 delete arg1;
21690
21691 wxPyEndAllowThreads(__tstate);
21692 if (PyErr_Occurred()) SWIG_fail;
21693 }
21694 resultobj = SWIG_Py_Void();
21695 return resultobj;
21696 fail:
21697 return NULL;
21698 }
21699
21700
21701 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21702 PyObject *resultobj = 0;
21703 wxEvent *arg1 = (wxEvent *) 0 ;
21704 wxEventType arg2 ;
21705 void *argp1 = 0 ;
21706 int res1 = 0 ;
21707 int val2 ;
21708 int ecode2 = 0 ;
21709 PyObject * obj0 = 0 ;
21710 PyObject * obj1 = 0 ;
21711 char * kwnames[] = {
21712 (char *) "self",(char *) "typ", NULL
21713 };
21714
21715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21717 if (!SWIG_IsOK(res1)) {
21718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21719 }
21720 arg1 = reinterpret_cast< wxEvent * >(argp1);
21721 ecode2 = SWIG_AsVal_int(obj1, &val2);
21722 if (!SWIG_IsOK(ecode2)) {
21723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21724 }
21725 arg2 = static_cast< wxEventType >(val2);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 (arg1)->SetEventType(arg2);
21729 wxPyEndAllowThreads(__tstate);
21730 if (PyErr_Occurred()) SWIG_fail;
21731 }
21732 resultobj = SWIG_Py_Void();
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 PyObject *resultobj = 0;
21741 wxEvent *arg1 = (wxEvent *) 0 ;
21742 wxEventType result;
21743 void *argp1 = 0 ;
21744 int res1 = 0 ;
21745 PyObject *swig_obj[1] ;
21746
21747 if (!args) SWIG_fail;
21748 swig_obj[0] = args;
21749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21750 if (!SWIG_IsOK(res1)) {
21751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21752 }
21753 arg1 = reinterpret_cast< wxEvent * >(argp1);
21754 {
21755 PyThreadState* __tstate = wxPyBeginAllowThreads();
21756 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21757 wxPyEndAllowThreads(__tstate);
21758 if (PyErr_Occurred()) SWIG_fail;
21759 }
21760 resultobj = SWIG_From_int(static_cast< int >(result));
21761 return resultobj;
21762 fail:
21763 return NULL;
21764 }
21765
21766
21767 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21768 PyObject *resultobj = 0;
21769 wxEvent *arg1 = (wxEvent *) 0 ;
21770 wxObject *result = 0 ;
21771 void *argp1 = 0 ;
21772 int res1 = 0 ;
21773 PyObject *swig_obj[1] ;
21774
21775 if (!args) SWIG_fail;
21776 swig_obj[0] = args;
21777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21778 if (!SWIG_IsOK(res1)) {
21779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21780 }
21781 arg1 = reinterpret_cast< wxEvent * >(argp1);
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 {
21789 resultobj = wxPyMake_wxObject(result, (bool)0);
21790 }
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21798 PyObject *resultobj = 0;
21799 wxEvent *arg1 = (wxEvent *) 0 ;
21800 wxObject *arg2 = (wxObject *) 0 ;
21801 void *argp1 = 0 ;
21802 int res1 = 0 ;
21803 void *argp2 = 0 ;
21804 int res2 = 0 ;
21805 PyObject * obj0 = 0 ;
21806 PyObject * obj1 = 0 ;
21807 char * kwnames[] = {
21808 (char *) "self",(char *) "obj", NULL
21809 };
21810
21811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21813 if (!SWIG_IsOK(res1)) {
21814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21815 }
21816 arg1 = reinterpret_cast< wxEvent * >(argp1);
21817 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21818 if (!SWIG_IsOK(res2)) {
21819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21820 }
21821 arg2 = reinterpret_cast< wxObject * >(argp2);
21822 {
21823 PyThreadState* __tstate = wxPyBeginAllowThreads();
21824 (arg1)->SetEventObject(arg2);
21825 wxPyEndAllowThreads(__tstate);
21826 if (PyErr_Occurred()) SWIG_fail;
21827 }
21828 resultobj = SWIG_Py_Void();
21829 return resultobj;
21830 fail:
21831 return NULL;
21832 }
21833
21834
21835 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21836 PyObject *resultobj = 0;
21837 wxEvent *arg1 = (wxEvent *) 0 ;
21838 long result;
21839 void *argp1 = 0 ;
21840 int res1 = 0 ;
21841 PyObject *swig_obj[1] ;
21842
21843 if (!args) SWIG_fail;
21844 swig_obj[0] = args;
21845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21846 if (!SWIG_IsOK(res1)) {
21847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21848 }
21849 arg1 = reinterpret_cast< wxEvent * >(argp1);
21850 {
21851 PyThreadState* __tstate = wxPyBeginAllowThreads();
21852 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21853 wxPyEndAllowThreads(__tstate);
21854 if (PyErr_Occurred()) SWIG_fail;
21855 }
21856 resultobj = SWIG_From_long(static_cast< long >(result));
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21864 PyObject *resultobj = 0;
21865 wxEvent *arg1 = (wxEvent *) 0 ;
21866 long arg2 = (long) 0 ;
21867 void *argp1 = 0 ;
21868 int res1 = 0 ;
21869 long val2 ;
21870 int ecode2 = 0 ;
21871 PyObject * obj0 = 0 ;
21872 PyObject * obj1 = 0 ;
21873 char * kwnames[] = {
21874 (char *) "self",(char *) "ts", NULL
21875 };
21876
21877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21879 if (!SWIG_IsOK(res1)) {
21880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21881 }
21882 arg1 = reinterpret_cast< wxEvent * >(argp1);
21883 if (obj1) {
21884 ecode2 = SWIG_AsVal_long(obj1, &val2);
21885 if (!SWIG_IsOK(ecode2)) {
21886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21887 }
21888 arg2 = static_cast< long >(val2);
21889 }
21890 {
21891 PyThreadState* __tstate = wxPyBeginAllowThreads();
21892 (arg1)->SetTimestamp(arg2);
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 resultobj = SWIG_Py_Void();
21897 return resultobj;
21898 fail:
21899 return NULL;
21900 }
21901
21902
21903 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21904 PyObject *resultobj = 0;
21905 wxEvent *arg1 = (wxEvent *) 0 ;
21906 int result;
21907 void *argp1 = 0 ;
21908 int res1 = 0 ;
21909 PyObject *swig_obj[1] ;
21910
21911 if (!args) SWIG_fail;
21912 swig_obj[0] = args;
21913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21914 if (!SWIG_IsOK(res1)) {
21915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21916 }
21917 arg1 = reinterpret_cast< wxEvent * >(argp1);
21918 {
21919 PyThreadState* __tstate = wxPyBeginAllowThreads();
21920 result = (int)((wxEvent const *)arg1)->GetId();
21921 wxPyEndAllowThreads(__tstate);
21922 if (PyErr_Occurred()) SWIG_fail;
21923 }
21924 resultobj = SWIG_From_int(static_cast< int >(result));
21925 return resultobj;
21926 fail:
21927 return NULL;
21928 }
21929
21930
21931 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21932 PyObject *resultobj = 0;
21933 wxEvent *arg1 = (wxEvent *) 0 ;
21934 int arg2 ;
21935 void *argp1 = 0 ;
21936 int res1 = 0 ;
21937 int val2 ;
21938 int ecode2 = 0 ;
21939 PyObject * obj0 = 0 ;
21940 PyObject * obj1 = 0 ;
21941 char * kwnames[] = {
21942 (char *) "self",(char *) "Id", NULL
21943 };
21944
21945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21947 if (!SWIG_IsOK(res1)) {
21948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21949 }
21950 arg1 = reinterpret_cast< wxEvent * >(argp1);
21951 ecode2 = SWIG_AsVal_int(obj1, &val2);
21952 if (!SWIG_IsOK(ecode2)) {
21953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21954 }
21955 arg2 = static_cast< int >(val2);
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 (arg1)->SetId(arg2);
21959 wxPyEndAllowThreads(__tstate);
21960 if (PyErr_Occurred()) SWIG_fail;
21961 }
21962 resultobj = SWIG_Py_Void();
21963 return resultobj;
21964 fail:
21965 return NULL;
21966 }
21967
21968
21969 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21970 PyObject *resultobj = 0;
21971 wxEvent *arg1 = (wxEvent *) 0 ;
21972 bool result;
21973 void *argp1 = 0 ;
21974 int res1 = 0 ;
21975 PyObject *swig_obj[1] ;
21976
21977 if (!args) SWIG_fail;
21978 swig_obj[0] = args;
21979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21980 if (!SWIG_IsOK(res1)) {
21981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21982 }
21983 arg1 = reinterpret_cast< wxEvent * >(argp1);
21984 {
21985 PyThreadState* __tstate = wxPyBeginAllowThreads();
21986 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21987 wxPyEndAllowThreads(__tstate);
21988 if (PyErr_Occurred()) SWIG_fail;
21989 }
21990 {
21991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21992 }
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22000 PyObject *resultobj = 0;
22001 wxEvent *arg1 = (wxEvent *) 0 ;
22002 bool arg2 = (bool) true ;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 bool val2 ;
22006 int ecode2 = 0 ;
22007 PyObject * obj0 = 0 ;
22008 PyObject * obj1 = 0 ;
22009 char * kwnames[] = {
22010 (char *) "self",(char *) "skip", NULL
22011 };
22012
22013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
22014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22015 if (!SWIG_IsOK(res1)) {
22016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
22017 }
22018 arg1 = reinterpret_cast< wxEvent * >(argp1);
22019 if (obj1) {
22020 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22021 if (!SWIG_IsOK(ecode2)) {
22022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
22023 }
22024 arg2 = static_cast< bool >(val2);
22025 }
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 (arg1)->Skip(arg2);
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 resultobj = SWIG_Py_Void();
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22040 PyObject *resultobj = 0;
22041 wxEvent *arg1 = (wxEvent *) 0 ;
22042 bool result;
22043 void *argp1 = 0 ;
22044 int res1 = 0 ;
22045 PyObject *swig_obj[1] ;
22046
22047 if (!args) SWIG_fail;
22048 swig_obj[0] = args;
22049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22050 if (!SWIG_IsOK(res1)) {
22051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
22052 }
22053 arg1 = reinterpret_cast< wxEvent * >(argp1);
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (bool)((wxEvent const *)arg1)->GetSkipped();
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 {
22061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22062 }
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22070 PyObject *resultobj = 0;
22071 wxEvent *arg1 = (wxEvent *) 0 ;
22072 bool result;
22073 void *argp1 = 0 ;
22074 int res1 = 0 ;
22075 PyObject *swig_obj[1] ;
22076
22077 if (!args) SWIG_fail;
22078 swig_obj[0] = args;
22079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
22082 }
22083 arg1 = reinterpret_cast< wxEvent * >(argp1);
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 {
22091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22092 }
22093 return resultobj;
22094 fail:
22095 return NULL;
22096 }
22097
22098
22099 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22100 PyObject *resultobj = 0;
22101 wxEvent *arg1 = (wxEvent *) 0 ;
22102 int result;
22103 void *argp1 = 0 ;
22104 int res1 = 0 ;
22105 PyObject *swig_obj[1] ;
22106
22107 if (!args) SWIG_fail;
22108 swig_obj[0] = args;
22109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22110 if (!SWIG_IsOK(res1)) {
22111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22112 }
22113 arg1 = reinterpret_cast< wxEvent * >(argp1);
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (int)(arg1)->StopPropagation();
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 resultobj = SWIG_From_int(static_cast< int >(result));
22121 return resultobj;
22122 fail:
22123 return NULL;
22124 }
22125
22126
22127 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22128 PyObject *resultobj = 0;
22129 wxEvent *arg1 = (wxEvent *) 0 ;
22130 int arg2 ;
22131 void *argp1 = 0 ;
22132 int res1 = 0 ;
22133 int val2 ;
22134 int ecode2 = 0 ;
22135 PyObject * obj0 = 0 ;
22136 PyObject * obj1 = 0 ;
22137 char * kwnames[] = {
22138 (char *) "self",(char *) "propagationLevel", NULL
22139 };
22140
22141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
22142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22145 }
22146 arg1 = reinterpret_cast< wxEvent * >(argp1);
22147 ecode2 = SWIG_AsVal_int(obj1, &val2);
22148 if (!SWIG_IsOK(ecode2)) {
22149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
22150 }
22151 arg2 = static_cast< int >(val2);
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 (arg1)->ResumePropagation(arg2);
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 resultobj = SWIG_Py_Void();
22159 return resultobj;
22160 fail:
22161 return NULL;
22162 }
22163
22164
22165 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22166 PyObject *resultobj = 0;
22167 wxEvent *arg1 = (wxEvent *) 0 ;
22168 wxEvent *result = 0 ;
22169 void *argp1 = 0 ;
22170 int res1 = 0 ;
22171 PyObject *swig_obj[1] ;
22172
22173 if (!args) SWIG_fail;
22174 swig_obj[0] = args;
22175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22176 if (!SWIG_IsOK(res1)) {
22177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
22178 }
22179 arg1 = reinterpret_cast< wxEvent * >(argp1);
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 result = (wxEvent *)(arg1)->Clone();
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22187 return resultobj;
22188 fail:
22189 return NULL;
22190 }
22191
22192
22193 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22194 PyObject *obj;
22195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22196 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
22197 return SWIG_Py_Void();
22198 }
22199
22200 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22201 PyObject *resultobj = 0;
22202 wxEvent *arg1 = 0 ;
22203 wxPropagationDisabler *result = 0 ;
22204 void *argp1 = 0 ;
22205 int res1 = 0 ;
22206 PyObject * obj0 = 0 ;
22207 char * kwnames[] = {
22208 (char *) "event", NULL
22209 };
22210
22211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
22212 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22213 if (!SWIG_IsOK(res1)) {
22214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22215 }
22216 if (!argp1) {
22217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22218 }
22219 arg1 = reinterpret_cast< wxEvent * >(argp1);
22220 {
22221 PyThreadState* __tstate = wxPyBeginAllowThreads();
22222 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
22223 wxPyEndAllowThreads(__tstate);
22224 if (PyErr_Occurred()) SWIG_fail;
22225 }
22226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
22227 return resultobj;
22228 fail:
22229 return NULL;
22230 }
22231
22232
22233 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22234 PyObject *resultobj = 0;
22235 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
22236 void *argp1 = 0 ;
22237 int res1 = 0 ;
22238 PyObject *swig_obj[1] ;
22239
22240 if (!args) SWIG_fail;
22241 swig_obj[0] = args;
22242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
22243 if (!SWIG_IsOK(res1)) {
22244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
22245 }
22246 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 delete arg1;
22250
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 resultobj = SWIG_Py_Void();
22255 return resultobj;
22256 fail:
22257 return NULL;
22258 }
22259
22260
22261 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22262 PyObject *obj;
22263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22264 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
22265 return SWIG_Py_Void();
22266 }
22267
22268 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22269 return SWIG_Python_InitShadowInstance(args);
22270 }
22271
22272 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22273 PyObject *resultobj = 0;
22274 wxEvent *arg1 = 0 ;
22275 wxPropagateOnce *result = 0 ;
22276 void *argp1 = 0 ;
22277 int res1 = 0 ;
22278 PyObject * obj0 = 0 ;
22279 char * kwnames[] = {
22280 (char *) "event", NULL
22281 };
22282
22283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
22284 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22285 if (!SWIG_IsOK(res1)) {
22286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22287 }
22288 if (!argp1) {
22289 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22290 }
22291 arg1 = reinterpret_cast< wxEvent * >(argp1);
22292 {
22293 PyThreadState* __tstate = wxPyBeginAllowThreads();
22294 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22306 PyObject *resultobj = 0;
22307 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
22308 void *argp1 = 0 ;
22309 int res1 = 0 ;
22310 PyObject *swig_obj[1] ;
22311
22312 if (!args) SWIG_fail;
22313 swig_obj[0] = args;
22314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
22315 if (!SWIG_IsOK(res1)) {
22316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
22317 }
22318 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
22319 {
22320 PyThreadState* __tstate = wxPyBeginAllowThreads();
22321 delete arg1;
22322
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 resultobj = SWIG_Py_Void();
22327 return resultobj;
22328 fail:
22329 return NULL;
22330 }
22331
22332
22333 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22334 PyObject *obj;
22335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22336 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
22337 return SWIG_Py_Void();
22338 }
22339
22340 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22341 return SWIG_Python_InitShadowInstance(args);
22342 }
22343
22344 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22345 PyObject *resultobj = 0;
22346 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22347 int arg2 = (int) 0 ;
22348 wxCommandEvent *result = 0 ;
22349 int val1 ;
22350 int ecode1 = 0 ;
22351 int val2 ;
22352 int ecode2 = 0 ;
22353 PyObject * obj0 = 0 ;
22354 PyObject * obj1 = 0 ;
22355 char * kwnames[] = {
22356 (char *) "commandType",(char *) "winid", NULL
22357 };
22358
22359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22360 if (obj0) {
22361 ecode1 = SWIG_AsVal_int(obj0, &val1);
22362 if (!SWIG_IsOK(ecode1)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22364 }
22365 arg1 = static_cast< wxEventType >(val1);
22366 }
22367 if (obj1) {
22368 ecode2 = SWIG_AsVal_int(obj1, &val2);
22369 if (!SWIG_IsOK(ecode2)) {
22370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
22371 }
22372 arg2 = static_cast< int >(val2);
22373 }
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
22377 wxPyEndAllowThreads(__tstate);
22378 if (PyErr_Occurred()) SWIG_fail;
22379 }
22380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
22381 return resultobj;
22382 fail:
22383 return NULL;
22384 }
22385
22386
22387 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22388 PyObject *resultobj = 0;
22389 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22390 int result;
22391 void *argp1 = 0 ;
22392 int res1 = 0 ;
22393 PyObject *swig_obj[1] ;
22394
22395 if (!args) SWIG_fail;
22396 swig_obj[0] = args;
22397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22398 if (!SWIG_IsOK(res1)) {
22399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22400 }
22401 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22402 {
22403 PyThreadState* __tstate = wxPyBeginAllowThreads();
22404 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
22405 wxPyEndAllowThreads(__tstate);
22406 if (PyErr_Occurred()) SWIG_fail;
22407 }
22408 resultobj = SWIG_From_int(static_cast< int >(result));
22409 return resultobj;
22410 fail:
22411 return NULL;
22412 }
22413
22414
22415 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22416 PyObject *resultobj = 0;
22417 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22418 wxString *arg2 = 0 ;
22419 void *argp1 = 0 ;
22420 int res1 = 0 ;
22421 bool temp2 = false ;
22422 PyObject * obj0 = 0 ;
22423 PyObject * obj1 = 0 ;
22424 char * kwnames[] = {
22425 (char *) "self",(char *) "s", NULL
22426 };
22427
22428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
22429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22430 if (!SWIG_IsOK(res1)) {
22431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22432 }
22433 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22434 {
22435 arg2 = wxString_in_helper(obj1);
22436 if (arg2 == NULL) SWIG_fail;
22437 temp2 = true;
22438 }
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 (arg1)->SetString((wxString const &)*arg2);
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 resultobj = SWIG_Py_Void();
22446 {
22447 if (temp2)
22448 delete arg2;
22449 }
22450 return resultobj;
22451 fail:
22452 {
22453 if (temp2)
22454 delete arg2;
22455 }
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 PyObject *resultobj = 0;
22462 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22463 wxString result;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 PyObject *swig_obj[1] ;
22467
22468 if (!args) SWIG_fail;
22469 swig_obj[0] = args;
22470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22471 if (!SWIG_IsOK(res1)) {
22472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22473 }
22474 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = ((wxCommandEvent const *)arg1)->GetString();
22478 wxPyEndAllowThreads(__tstate);
22479 if (PyErr_Occurred()) SWIG_fail;
22480 }
22481 {
22482 #if wxUSE_UNICODE
22483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22484 #else
22485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22486 #endif
22487 }
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22495 PyObject *resultobj = 0;
22496 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22497 bool result;
22498 void *argp1 = 0 ;
22499 int res1 = 0 ;
22500 PyObject *swig_obj[1] ;
22501
22502 if (!args) SWIG_fail;
22503 swig_obj[0] = args;
22504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22505 if (!SWIG_IsOK(res1)) {
22506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22507 }
22508 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22509 {
22510 PyThreadState* __tstate = wxPyBeginAllowThreads();
22511 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
22512 wxPyEndAllowThreads(__tstate);
22513 if (PyErr_Occurred()) SWIG_fail;
22514 }
22515 {
22516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22517 }
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22525 PyObject *resultobj = 0;
22526 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22527 bool result;
22528 void *argp1 = 0 ;
22529 int res1 = 0 ;
22530 PyObject *swig_obj[1] ;
22531
22532 if (!args) SWIG_fail;
22533 swig_obj[0] = args;
22534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22535 if (!SWIG_IsOK(res1)) {
22536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22537 }
22538 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22539 {
22540 PyThreadState* __tstate = wxPyBeginAllowThreads();
22541 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 {
22546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22547 }
22548 return resultobj;
22549 fail:
22550 return NULL;
22551 }
22552
22553
22554 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22555 PyObject *resultobj = 0;
22556 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22557 long arg2 ;
22558 void *argp1 = 0 ;
22559 int res1 = 0 ;
22560 long val2 ;
22561 int ecode2 = 0 ;
22562 PyObject * obj0 = 0 ;
22563 PyObject * obj1 = 0 ;
22564 char * kwnames[] = {
22565 (char *) "self",(char *) "extraLong", NULL
22566 };
22567
22568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22570 if (!SWIG_IsOK(res1)) {
22571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22572 }
22573 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22574 ecode2 = SWIG_AsVal_long(obj1, &val2);
22575 if (!SWIG_IsOK(ecode2)) {
22576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22577 }
22578 arg2 = static_cast< long >(val2);
22579 {
22580 PyThreadState* __tstate = wxPyBeginAllowThreads();
22581 (arg1)->SetExtraLong(arg2);
22582 wxPyEndAllowThreads(__tstate);
22583 if (PyErr_Occurred()) SWIG_fail;
22584 }
22585 resultobj = SWIG_Py_Void();
22586 return resultobj;
22587 fail:
22588 return NULL;
22589 }
22590
22591
22592 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22593 PyObject *resultobj = 0;
22594 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22595 long result;
22596 void *argp1 = 0 ;
22597 int res1 = 0 ;
22598 PyObject *swig_obj[1] ;
22599
22600 if (!args) SWIG_fail;
22601 swig_obj[0] = args;
22602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22603 if (!SWIG_IsOK(res1)) {
22604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22605 }
22606 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22610 wxPyEndAllowThreads(__tstate);
22611 if (PyErr_Occurred()) SWIG_fail;
22612 }
22613 resultobj = SWIG_From_long(static_cast< long >(result));
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22621 PyObject *resultobj = 0;
22622 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22623 int arg2 ;
22624 void *argp1 = 0 ;
22625 int res1 = 0 ;
22626 int val2 ;
22627 int ecode2 = 0 ;
22628 PyObject * obj0 = 0 ;
22629 PyObject * obj1 = 0 ;
22630 char * kwnames[] = {
22631 (char *) "self",(char *) "i", NULL
22632 };
22633
22634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22638 }
22639 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22640 ecode2 = SWIG_AsVal_int(obj1, &val2);
22641 if (!SWIG_IsOK(ecode2)) {
22642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22643 }
22644 arg2 = static_cast< int >(val2);
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 (arg1)->SetInt(arg2);
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 resultobj = SWIG_Py_Void();
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22659 PyObject *resultobj = 0;
22660 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22661 int result;
22662 void *argp1 = 0 ;
22663 int res1 = 0 ;
22664 PyObject *swig_obj[1] ;
22665
22666 if (!args) SWIG_fail;
22667 swig_obj[0] = args;
22668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22669 if (!SWIG_IsOK(res1)) {
22670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22671 }
22672 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22676 wxPyEndAllowThreads(__tstate);
22677 if (PyErr_Occurred()) SWIG_fail;
22678 }
22679 resultobj = SWIG_From_int(static_cast< int >(result));
22680 return resultobj;
22681 fail:
22682 return NULL;
22683 }
22684
22685
22686 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22687 PyObject *resultobj = 0;
22688 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22689 PyObject *result = 0 ;
22690 void *argp1 = 0 ;
22691 int res1 = 0 ;
22692 PyObject *swig_obj[1] ;
22693
22694 if (!args) SWIG_fail;
22695 swig_obj[0] = args;
22696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22697 if (!SWIG_IsOK(res1)) {
22698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22699 }
22700 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22701 {
22702 PyThreadState* __tstate = wxPyBeginAllowThreads();
22703 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22704 wxPyEndAllowThreads(__tstate);
22705 if (PyErr_Occurred()) SWIG_fail;
22706 }
22707 resultobj = result;
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22715 PyObject *resultobj = 0;
22716 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22717 PyObject *arg2 = (PyObject *) 0 ;
22718 void *argp1 = 0 ;
22719 int res1 = 0 ;
22720 PyObject * obj0 = 0 ;
22721 PyObject * obj1 = 0 ;
22722 char * kwnames[] = {
22723 (char *) "self",(char *) "clientData", NULL
22724 };
22725
22726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22728 if (!SWIG_IsOK(res1)) {
22729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22730 }
22731 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22732 arg2 = obj1;
22733 {
22734 PyThreadState* __tstate = wxPyBeginAllowThreads();
22735 wxCommandEvent_SetClientData(arg1,arg2);
22736 wxPyEndAllowThreads(__tstate);
22737 if (PyErr_Occurred()) SWIG_fail;
22738 }
22739 resultobj = SWIG_Py_Void();
22740 return resultobj;
22741 fail:
22742 return NULL;
22743 }
22744
22745
22746 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22747 PyObject *resultobj = 0;
22748 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22749 wxEvent *result = 0 ;
22750 void *argp1 = 0 ;
22751 int res1 = 0 ;
22752 PyObject *swig_obj[1] ;
22753
22754 if (!args) SWIG_fail;
22755 swig_obj[0] = args;
22756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22757 if (!SWIG_IsOK(res1)) {
22758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22759 }
22760 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22761 {
22762 PyThreadState* __tstate = wxPyBeginAllowThreads();
22763 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22764 wxPyEndAllowThreads(__tstate);
22765 if (PyErr_Occurred()) SWIG_fail;
22766 }
22767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22768 return resultobj;
22769 fail:
22770 return NULL;
22771 }
22772
22773
22774 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22775 PyObject *obj;
22776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22777 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22778 return SWIG_Py_Void();
22779 }
22780
22781 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22782 return SWIG_Python_InitShadowInstance(args);
22783 }
22784
22785 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22786 PyObject *resultobj = 0;
22787 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22788 int arg2 = (int) 0 ;
22789 wxNotifyEvent *result = 0 ;
22790 int val1 ;
22791 int ecode1 = 0 ;
22792 int val2 ;
22793 int ecode2 = 0 ;
22794 PyObject * obj0 = 0 ;
22795 PyObject * obj1 = 0 ;
22796 char * kwnames[] = {
22797 (char *) "commandType",(char *) "winid", NULL
22798 };
22799
22800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22801 if (obj0) {
22802 ecode1 = SWIG_AsVal_int(obj0, &val1);
22803 if (!SWIG_IsOK(ecode1)) {
22804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22805 }
22806 arg1 = static_cast< wxEventType >(val1);
22807 }
22808 if (obj1) {
22809 ecode2 = SWIG_AsVal_int(obj1, &val2);
22810 if (!SWIG_IsOK(ecode2)) {
22811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22812 }
22813 arg2 = static_cast< int >(val2);
22814 }
22815 {
22816 PyThreadState* __tstate = wxPyBeginAllowThreads();
22817 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22818 wxPyEndAllowThreads(__tstate);
22819 if (PyErr_Occurred()) SWIG_fail;
22820 }
22821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22822 return resultobj;
22823 fail:
22824 return NULL;
22825 }
22826
22827
22828 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22829 PyObject *resultobj = 0;
22830 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22831 void *argp1 = 0 ;
22832 int res1 = 0 ;
22833 PyObject *swig_obj[1] ;
22834
22835 if (!args) SWIG_fail;
22836 swig_obj[0] = args;
22837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22838 if (!SWIG_IsOK(res1)) {
22839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22840 }
22841 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22842 {
22843 PyThreadState* __tstate = wxPyBeginAllowThreads();
22844 (arg1)->Veto();
22845 wxPyEndAllowThreads(__tstate);
22846 if (PyErr_Occurred()) SWIG_fail;
22847 }
22848 resultobj = SWIG_Py_Void();
22849 return resultobj;
22850 fail:
22851 return NULL;
22852 }
22853
22854
22855 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22856 PyObject *resultobj = 0;
22857 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22858 void *argp1 = 0 ;
22859 int res1 = 0 ;
22860 PyObject *swig_obj[1] ;
22861
22862 if (!args) SWIG_fail;
22863 swig_obj[0] = args;
22864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22865 if (!SWIG_IsOK(res1)) {
22866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22867 }
22868 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22869 {
22870 PyThreadState* __tstate = wxPyBeginAllowThreads();
22871 (arg1)->Allow();
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 resultobj = SWIG_Py_Void();
22876 return resultobj;
22877 fail:
22878 return NULL;
22879 }
22880
22881
22882 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22883 PyObject *resultobj = 0;
22884 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22885 bool result;
22886 void *argp1 = 0 ;
22887 int res1 = 0 ;
22888 PyObject *swig_obj[1] ;
22889
22890 if (!args) SWIG_fail;
22891 swig_obj[0] = args;
22892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22893 if (!SWIG_IsOK(res1)) {
22894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22895 }
22896 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22897 {
22898 PyThreadState* __tstate = wxPyBeginAllowThreads();
22899 result = (bool)(arg1)->IsAllowed();
22900 wxPyEndAllowThreads(__tstate);
22901 if (PyErr_Occurred()) SWIG_fail;
22902 }
22903 {
22904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22905 }
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22913 PyObject *obj;
22914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22915 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22916 return SWIG_Py_Void();
22917 }
22918
22919 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22920 return SWIG_Python_InitShadowInstance(args);
22921 }
22922
22923 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22924 PyObject *resultobj = 0;
22925 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22926 int arg2 = (int) 0 ;
22927 int arg3 = (int) 0 ;
22928 int arg4 = (int) 0 ;
22929 wxScrollEvent *result = 0 ;
22930 int val1 ;
22931 int ecode1 = 0 ;
22932 int val2 ;
22933 int ecode2 = 0 ;
22934 int val3 ;
22935 int ecode3 = 0 ;
22936 int val4 ;
22937 int ecode4 = 0 ;
22938 PyObject * obj0 = 0 ;
22939 PyObject * obj1 = 0 ;
22940 PyObject * obj2 = 0 ;
22941 PyObject * obj3 = 0 ;
22942 char * kwnames[] = {
22943 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22944 };
22945
22946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22947 if (obj0) {
22948 ecode1 = SWIG_AsVal_int(obj0, &val1);
22949 if (!SWIG_IsOK(ecode1)) {
22950 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22951 }
22952 arg1 = static_cast< wxEventType >(val1);
22953 }
22954 if (obj1) {
22955 ecode2 = SWIG_AsVal_int(obj1, &val2);
22956 if (!SWIG_IsOK(ecode2)) {
22957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22958 }
22959 arg2 = static_cast< int >(val2);
22960 }
22961 if (obj2) {
22962 ecode3 = SWIG_AsVal_int(obj2, &val3);
22963 if (!SWIG_IsOK(ecode3)) {
22964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22965 }
22966 arg3 = static_cast< int >(val3);
22967 }
22968 if (obj3) {
22969 ecode4 = SWIG_AsVal_int(obj3, &val4);
22970 if (!SWIG_IsOK(ecode4)) {
22971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22972 }
22973 arg4 = static_cast< int >(val4);
22974 }
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22989 PyObject *resultobj = 0;
22990 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22991 int result;
22992 void *argp1 = 0 ;
22993 int res1 = 0 ;
22994 PyObject *swig_obj[1] ;
22995
22996 if (!args) SWIG_fail;
22997 swig_obj[0] = args;
22998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22999 if (!SWIG_IsOK(res1)) {
23000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23001 }
23002 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23003 {
23004 PyThreadState* __tstate = wxPyBeginAllowThreads();
23005 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
23006 wxPyEndAllowThreads(__tstate);
23007 if (PyErr_Occurred()) SWIG_fail;
23008 }
23009 resultobj = SWIG_From_int(static_cast< int >(result));
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23017 PyObject *resultobj = 0;
23018 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23019 int result;
23020 void *argp1 = 0 ;
23021 int res1 = 0 ;
23022 PyObject *swig_obj[1] ;
23023
23024 if (!args) SWIG_fail;
23025 swig_obj[0] = args;
23026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23027 if (!SWIG_IsOK(res1)) {
23028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23029 }
23030 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23031 {
23032 PyThreadState* __tstate = wxPyBeginAllowThreads();
23033 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
23034 wxPyEndAllowThreads(__tstate);
23035 if (PyErr_Occurred()) SWIG_fail;
23036 }
23037 resultobj = SWIG_From_int(static_cast< int >(result));
23038 return resultobj;
23039 fail:
23040 return NULL;
23041 }
23042
23043
23044 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23045 PyObject *resultobj = 0;
23046 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23047 int arg2 ;
23048 void *argp1 = 0 ;
23049 int res1 = 0 ;
23050 int val2 ;
23051 int ecode2 = 0 ;
23052 PyObject * obj0 = 0 ;
23053 PyObject * obj1 = 0 ;
23054 char * kwnames[] = {
23055 (char *) "self",(char *) "orient", NULL
23056 };
23057
23058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23060 if (!SWIG_IsOK(res1)) {
23061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23062 }
23063 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23064 ecode2 = SWIG_AsVal_int(obj1, &val2);
23065 if (!SWIG_IsOK(ecode2)) {
23066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23067 }
23068 arg2 = static_cast< int >(val2);
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 (arg1)->SetOrientation(arg2);
23072 wxPyEndAllowThreads(__tstate);
23073 if (PyErr_Occurred()) SWIG_fail;
23074 }
23075 resultobj = SWIG_Py_Void();
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23083 PyObject *resultobj = 0;
23084 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23085 int arg2 ;
23086 void *argp1 = 0 ;
23087 int res1 = 0 ;
23088 int val2 ;
23089 int ecode2 = 0 ;
23090 PyObject * obj0 = 0 ;
23091 PyObject * obj1 = 0 ;
23092 char * kwnames[] = {
23093 (char *) "self",(char *) "pos", NULL
23094 };
23095
23096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23098 if (!SWIG_IsOK(res1)) {
23099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23100 }
23101 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23102 ecode2 = SWIG_AsVal_int(obj1, &val2);
23103 if (!SWIG_IsOK(ecode2)) {
23104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23105 }
23106 arg2 = static_cast< int >(val2);
23107 {
23108 PyThreadState* __tstate = wxPyBeginAllowThreads();
23109 (arg1)->SetPosition(arg2);
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 resultobj = SWIG_Py_Void();
23114 return resultobj;
23115 fail:
23116 return NULL;
23117 }
23118
23119
23120 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23121 PyObject *obj;
23122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23123 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
23124 return SWIG_Py_Void();
23125 }
23126
23127 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23128 return SWIG_Python_InitShadowInstance(args);
23129 }
23130
23131 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23132 PyObject *resultobj = 0;
23133 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23134 int arg2 = (int) 0 ;
23135 int arg3 = (int) 0 ;
23136 wxScrollWinEvent *result = 0 ;
23137 int val1 ;
23138 int ecode1 = 0 ;
23139 int val2 ;
23140 int ecode2 = 0 ;
23141 int val3 ;
23142 int ecode3 = 0 ;
23143 PyObject * obj0 = 0 ;
23144 PyObject * obj1 = 0 ;
23145 PyObject * obj2 = 0 ;
23146 char * kwnames[] = {
23147 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
23148 };
23149
23150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23151 if (obj0) {
23152 ecode1 = SWIG_AsVal_int(obj0, &val1);
23153 if (!SWIG_IsOK(ecode1)) {
23154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23155 }
23156 arg1 = static_cast< wxEventType >(val1);
23157 }
23158 if (obj1) {
23159 ecode2 = SWIG_AsVal_int(obj1, &val2);
23160 if (!SWIG_IsOK(ecode2)) {
23161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
23162 }
23163 arg2 = static_cast< int >(val2);
23164 }
23165 if (obj2) {
23166 ecode3 = SWIG_AsVal_int(obj2, &val3);
23167 if (!SWIG_IsOK(ecode3)) {
23168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
23169 }
23170 arg3 = static_cast< int >(val3);
23171 }
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
23175 wxPyEndAllowThreads(__tstate);
23176 if (PyErr_Occurred()) SWIG_fail;
23177 }
23178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
23179 return resultobj;
23180 fail:
23181 return NULL;
23182 }
23183
23184
23185 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23186 PyObject *resultobj = 0;
23187 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23188 int result;
23189 void *argp1 = 0 ;
23190 int res1 = 0 ;
23191 PyObject *swig_obj[1] ;
23192
23193 if (!args) SWIG_fail;
23194 swig_obj[0] = args;
23195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23196 if (!SWIG_IsOK(res1)) {
23197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23198 }
23199 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 resultobj = SWIG_From_int(static_cast< int >(result));
23207 return resultobj;
23208 fail:
23209 return NULL;
23210 }
23211
23212
23213 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23214 PyObject *resultobj = 0;
23215 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23216 int result;
23217 void *argp1 = 0 ;
23218 int res1 = 0 ;
23219 PyObject *swig_obj[1] ;
23220
23221 if (!args) SWIG_fail;
23222 swig_obj[0] = args;
23223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23224 if (!SWIG_IsOK(res1)) {
23225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23226 }
23227 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23228 {
23229 PyThreadState* __tstate = wxPyBeginAllowThreads();
23230 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
23231 wxPyEndAllowThreads(__tstate);
23232 if (PyErr_Occurred()) SWIG_fail;
23233 }
23234 resultobj = SWIG_From_int(static_cast< int >(result));
23235 return resultobj;
23236 fail:
23237 return NULL;
23238 }
23239
23240
23241 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23242 PyObject *resultobj = 0;
23243 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23244 int arg2 ;
23245 void *argp1 = 0 ;
23246 int res1 = 0 ;
23247 int val2 ;
23248 int ecode2 = 0 ;
23249 PyObject * obj0 = 0 ;
23250 PyObject * obj1 = 0 ;
23251 char * kwnames[] = {
23252 (char *) "self",(char *) "orient", NULL
23253 };
23254
23255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23257 if (!SWIG_IsOK(res1)) {
23258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23259 }
23260 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23261 ecode2 = SWIG_AsVal_int(obj1, &val2);
23262 if (!SWIG_IsOK(ecode2)) {
23263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23264 }
23265 arg2 = static_cast< int >(val2);
23266 {
23267 PyThreadState* __tstate = wxPyBeginAllowThreads();
23268 (arg1)->SetOrientation(arg2);
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 resultobj = SWIG_Py_Void();
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj = 0;
23281 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23282 int arg2 ;
23283 void *argp1 = 0 ;
23284 int res1 = 0 ;
23285 int val2 ;
23286 int ecode2 = 0 ;
23287 PyObject * obj0 = 0 ;
23288 PyObject * obj1 = 0 ;
23289 char * kwnames[] = {
23290 (char *) "self",(char *) "pos", NULL
23291 };
23292
23293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23295 if (!SWIG_IsOK(res1)) {
23296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23297 }
23298 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23299 ecode2 = SWIG_AsVal_int(obj1, &val2);
23300 if (!SWIG_IsOK(ecode2)) {
23301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23302 }
23303 arg2 = static_cast< int >(val2);
23304 {
23305 PyThreadState* __tstate = wxPyBeginAllowThreads();
23306 (arg1)->SetPosition(arg2);
23307 wxPyEndAllowThreads(__tstate);
23308 if (PyErr_Occurred()) SWIG_fail;
23309 }
23310 resultobj = SWIG_Py_Void();
23311 return resultobj;
23312 fail:
23313 return NULL;
23314 }
23315
23316
23317 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23318 PyObject *obj;
23319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23320 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
23321 return SWIG_Py_Void();
23322 }
23323
23324 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23325 return SWIG_Python_InitShadowInstance(args);
23326 }
23327
23328 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23329 PyObject *resultobj = 0;
23330 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23331 wxMouseEvent *result = 0 ;
23332 int val1 ;
23333 int ecode1 = 0 ;
23334 PyObject * obj0 = 0 ;
23335 char * kwnames[] = {
23336 (char *) "mouseType", NULL
23337 };
23338
23339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
23340 if (obj0) {
23341 ecode1 = SWIG_AsVal_int(obj0, &val1);
23342 if (!SWIG_IsOK(ecode1)) {
23343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23344 }
23345 arg1 = static_cast< wxEventType >(val1);
23346 }
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 result = (wxMouseEvent *)new wxMouseEvent(arg1);
23350 wxPyEndAllowThreads(__tstate);
23351 if (PyErr_Occurred()) SWIG_fail;
23352 }
23353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
23354 return resultobj;
23355 fail:
23356 return NULL;
23357 }
23358
23359
23360 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23361 PyObject *resultobj = 0;
23362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23363 bool result;
23364 void *argp1 = 0 ;
23365 int res1 = 0 ;
23366 PyObject *swig_obj[1] ;
23367
23368 if (!args) SWIG_fail;
23369 swig_obj[0] = args;
23370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23371 if (!SWIG_IsOK(res1)) {
23372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23373 }
23374 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 {
23382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23383 }
23384 return resultobj;
23385 fail:
23386 return NULL;
23387 }
23388
23389
23390 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23391 PyObject *resultobj = 0;
23392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23393 int arg2 = (int) wxMOUSE_BTN_ANY ;
23394 bool result;
23395 void *argp1 = 0 ;
23396 int res1 = 0 ;
23397 int val2 ;
23398 int ecode2 = 0 ;
23399 PyObject * obj0 = 0 ;
23400 PyObject * obj1 = 0 ;
23401 char * kwnames[] = {
23402 (char *) "self",(char *) "but", NULL
23403 };
23404
23405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
23406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23407 if (!SWIG_IsOK(res1)) {
23408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23409 }
23410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23411 if (obj1) {
23412 ecode2 = SWIG_AsVal_int(obj1, &val2);
23413 if (!SWIG_IsOK(ecode2)) {
23414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
23415 }
23416 arg2 = static_cast< int >(val2);
23417 }
23418 {
23419 PyThreadState* __tstate = wxPyBeginAllowThreads();
23420 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
23421 wxPyEndAllowThreads(__tstate);
23422 if (PyErr_Occurred()) SWIG_fail;
23423 }
23424 {
23425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23426 }
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj = 0;
23435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23436 int arg2 = (int) wxMOUSE_BTN_ANY ;
23437 bool result;
23438 void *argp1 = 0 ;
23439 int res1 = 0 ;
23440 int val2 ;
23441 int ecode2 = 0 ;
23442 PyObject * obj0 = 0 ;
23443 PyObject * obj1 = 0 ;
23444 char * kwnames[] = {
23445 (char *) "self",(char *) "but", NULL
23446 };
23447
23448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
23449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23450 if (!SWIG_IsOK(res1)) {
23451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23452 }
23453 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23454 if (obj1) {
23455 ecode2 = SWIG_AsVal_int(obj1, &val2);
23456 if (!SWIG_IsOK(ecode2)) {
23457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
23458 }
23459 arg2 = static_cast< int >(val2);
23460 }
23461 {
23462 PyThreadState* __tstate = wxPyBeginAllowThreads();
23463 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
23464 wxPyEndAllowThreads(__tstate);
23465 if (PyErr_Occurred()) SWIG_fail;
23466 }
23467 {
23468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23469 }
23470 return resultobj;
23471 fail:
23472 return NULL;
23473 }
23474
23475
23476 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23477 PyObject *resultobj = 0;
23478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23479 int arg2 = (int) wxMOUSE_BTN_ANY ;
23480 bool result;
23481 void *argp1 = 0 ;
23482 int res1 = 0 ;
23483 int val2 ;
23484 int ecode2 = 0 ;
23485 PyObject * obj0 = 0 ;
23486 PyObject * obj1 = 0 ;
23487 char * kwnames[] = {
23488 (char *) "self",(char *) "but", NULL
23489 };
23490
23491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
23492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23493 if (!SWIG_IsOK(res1)) {
23494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23495 }
23496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23497 if (obj1) {
23498 ecode2 = SWIG_AsVal_int(obj1, &val2);
23499 if (!SWIG_IsOK(ecode2)) {
23500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
23501 }
23502 arg2 = static_cast< int >(val2);
23503 }
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
23507 wxPyEndAllowThreads(__tstate);
23508 if (PyErr_Occurred()) SWIG_fail;
23509 }
23510 {
23511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23512 }
23513 return resultobj;
23514 fail:
23515 return NULL;
23516 }
23517
23518
23519 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23520 PyObject *resultobj = 0;
23521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23522 int arg2 ;
23523 bool result;
23524 void *argp1 = 0 ;
23525 int res1 = 0 ;
23526 int val2 ;
23527 int ecode2 = 0 ;
23528 PyObject * obj0 = 0 ;
23529 PyObject * obj1 = 0 ;
23530 char * kwnames[] = {
23531 (char *) "self",(char *) "button", NULL
23532 };
23533
23534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23536 if (!SWIG_IsOK(res1)) {
23537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23538 }
23539 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23540 ecode2 = SWIG_AsVal_int(obj1, &val2);
23541 if (!SWIG_IsOK(ecode2)) {
23542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23543 }
23544 arg2 = static_cast< int >(val2);
23545 {
23546 PyThreadState* __tstate = wxPyBeginAllowThreads();
23547 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23548 wxPyEndAllowThreads(__tstate);
23549 if (PyErr_Occurred()) SWIG_fail;
23550 }
23551 {
23552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23553 }
23554 return resultobj;
23555 fail:
23556 return NULL;
23557 }
23558
23559
23560 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23561 PyObject *resultobj = 0;
23562 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23563 int arg2 ;
23564 bool result;
23565 void *argp1 = 0 ;
23566 int res1 = 0 ;
23567 int val2 ;
23568 int ecode2 = 0 ;
23569 PyObject * obj0 = 0 ;
23570 PyObject * obj1 = 0 ;
23571 char * kwnames[] = {
23572 (char *) "self",(char *) "but", NULL
23573 };
23574
23575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23577 if (!SWIG_IsOK(res1)) {
23578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23579 }
23580 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23581 ecode2 = SWIG_AsVal_int(obj1, &val2);
23582 if (!SWIG_IsOK(ecode2)) {
23583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23584 }
23585 arg2 = static_cast< int >(val2);
23586 {
23587 PyThreadState* __tstate = wxPyBeginAllowThreads();
23588 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23589 wxPyEndAllowThreads(__tstate);
23590 if (PyErr_Occurred()) SWIG_fail;
23591 }
23592 {
23593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23594 }
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23602 PyObject *resultobj = 0;
23603 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23604 int result;
23605 void *argp1 = 0 ;
23606 int res1 = 0 ;
23607 PyObject *swig_obj[1] ;
23608
23609 if (!args) SWIG_fail;
23610 swig_obj[0] = args;
23611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23612 if (!SWIG_IsOK(res1)) {
23613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23614 }
23615 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23616 {
23617 PyThreadState* __tstate = wxPyBeginAllowThreads();
23618 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 resultobj = SWIG_From_int(static_cast< int >(result));
23623 return resultobj;
23624 fail:
23625 return NULL;
23626 }
23627
23628
23629 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23630 PyObject *resultobj = 0;
23631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23632 bool result;
23633 void *argp1 = 0 ;
23634 int res1 = 0 ;
23635 PyObject *swig_obj[1] ;
23636
23637 if (!args) SWIG_fail;
23638 swig_obj[0] = args;
23639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23640 if (!SWIG_IsOK(res1)) {
23641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23642 }
23643 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23644 {
23645 PyThreadState* __tstate = wxPyBeginAllowThreads();
23646 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23647 wxPyEndAllowThreads(__tstate);
23648 if (PyErr_Occurred()) SWIG_fail;
23649 }
23650 {
23651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23652 }
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23660 PyObject *resultobj = 0;
23661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23662 bool result;
23663 void *argp1 = 0 ;
23664 int res1 = 0 ;
23665 PyObject *swig_obj[1] ;
23666
23667 if (!args) SWIG_fail;
23668 swig_obj[0] = args;
23669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23670 if (!SWIG_IsOK(res1)) {
23671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23672 }
23673 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23674 {
23675 PyThreadState* __tstate = wxPyBeginAllowThreads();
23676 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23677 wxPyEndAllowThreads(__tstate);
23678 if (PyErr_Occurred()) SWIG_fail;
23679 }
23680 {
23681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23682 }
23683 return resultobj;
23684 fail:
23685 return NULL;
23686 }
23687
23688
23689 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23690 PyObject *resultobj = 0;
23691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23692 bool result;
23693 void *argp1 = 0 ;
23694 int res1 = 0 ;
23695 PyObject *swig_obj[1] ;
23696
23697 if (!args) SWIG_fail;
23698 swig_obj[0] = args;
23699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23700 if (!SWIG_IsOK(res1)) {
23701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23702 }
23703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23704 {
23705 PyThreadState* __tstate = wxPyBeginAllowThreads();
23706 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23707 wxPyEndAllowThreads(__tstate);
23708 if (PyErr_Occurred()) SWIG_fail;
23709 }
23710 {
23711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23712 }
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23720 PyObject *resultobj = 0;
23721 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23722 bool result;
23723 void *argp1 = 0 ;
23724 int res1 = 0 ;
23725 PyObject *swig_obj[1] ;
23726
23727 if (!args) SWIG_fail;
23728 swig_obj[0] = args;
23729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23730 if (!SWIG_IsOK(res1)) {
23731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23732 }
23733 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23734 {
23735 PyThreadState* __tstate = wxPyBeginAllowThreads();
23736 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23737 wxPyEndAllowThreads(__tstate);
23738 if (PyErr_Occurred()) SWIG_fail;
23739 }
23740 {
23741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23742 }
23743 return resultobj;
23744 fail:
23745 return NULL;
23746 }
23747
23748
23749 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23750 PyObject *resultobj = 0;
23751 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23752 bool result;
23753 void *argp1 = 0 ;
23754 int res1 = 0 ;
23755 PyObject *swig_obj[1] ;
23756
23757 if (!args) SWIG_fail;
23758 swig_obj[0] = args;
23759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23760 if (!SWIG_IsOK(res1)) {
23761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23762 }
23763 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23767 wxPyEndAllowThreads(__tstate);
23768 if (PyErr_Occurred()) SWIG_fail;
23769 }
23770 {
23771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23772 }
23773 return resultobj;
23774 fail:
23775 return NULL;
23776 }
23777
23778
23779 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23780 PyObject *resultobj = 0;
23781 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23782 bool result;
23783 void *argp1 = 0 ;
23784 int res1 = 0 ;
23785 PyObject *swig_obj[1] ;
23786
23787 if (!args) SWIG_fail;
23788 swig_obj[0] = args;
23789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23790 if (!SWIG_IsOK(res1)) {
23791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23792 }
23793 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 {
23801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23802 }
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 PyObject *resultobj = 0;
23811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23812 bool result;
23813 void *argp1 = 0 ;
23814 int res1 = 0 ;
23815 PyObject *swig_obj[1] ;
23816
23817 if (!args) SWIG_fail;
23818 swig_obj[0] = args;
23819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23820 if (!SWIG_IsOK(res1)) {
23821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23822 }
23823 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23824 {
23825 PyThreadState* __tstate = wxPyBeginAllowThreads();
23826 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23827 wxPyEndAllowThreads(__tstate);
23828 if (PyErr_Occurred()) SWIG_fail;
23829 }
23830 {
23831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23832 }
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23842 bool result;
23843 void *argp1 = 0 ;
23844 int res1 = 0 ;
23845 PyObject *swig_obj[1] ;
23846
23847 if (!args) SWIG_fail;
23848 swig_obj[0] = args;
23849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23850 if (!SWIG_IsOK(res1)) {
23851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23852 }
23853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 {
23861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23862 }
23863 return resultobj;
23864 fail:
23865 return NULL;
23866 }
23867
23868
23869 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23870 PyObject *resultobj = 0;
23871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23872 bool result;
23873 void *argp1 = 0 ;
23874 int res1 = 0 ;
23875 PyObject *swig_obj[1] ;
23876
23877 if (!args) SWIG_fail;
23878 swig_obj[0] = args;
23879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23880 if (!SWIG_IsOK(res1)) {
23881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23882 }
23883 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23884 {
23885 PyThreadState* __tstate = wxPyBeginAllowThreads();
23886 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23887 wxPyEndAllowThreads(__tstate);
23888 if (PyErr_Occurred()) SWIG_fail;
23889 }
23890 {
23891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23892 }
23893 return resultobj;
23894 fail:
23895 return NULL;
23896 }
23897
23898
23899 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23900 PyObject *resultobj = 0;
23901 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23902 bool result;
23903 void *argp1 = 0 ;
23904 int res1 = 0 ;
23905 PyObject *swig_obj[1] ;
23906
23907 if (!args) SWIG_fail;
23908 swig_obj[0] = args;
23909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23910 if (!SWIG_IsOK(res1)) {
23911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23912 }
23913 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23930 PyObject *resultobj = 0;
23931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23932 bool result;
23933 void *argp1 = 0 ;
23934 int res1 = 0 ;
23935 PyObject *swig_obj[1] ;
23936
23937 if (!args) SWIG_fail;
23938 swig_obj[0] = args;
23939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23940 if (!SWIG_IsOK(res1)) {
23941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23942 }
23943 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23944 {
23945 PyThreadState* __tstate = wxPyBeginAllowThreads();
23946 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23947 wxPyEndAllowThreads(__tstate);
23948 if (PyErr_Occurred()) SWIG_fail;
23949 }
23950 {
23951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23952 }
23953 return resultobj;
23954 fail:
23955 return NULL;
23956 }
23957
23958
23959 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23960 PyObject *resultobj = 0;
23961 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23962 bool result;
23963 void *argp1 = 0 ;
23964 int res1 = 0 ;
23965 PyObject *swig_obj[1] ;
23966
23967 if (!args) SWIG_fail;
23968 swig_obj[0] = args;
23969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23970 if (!SWIG_IsOK(res1)) {
23971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23972 }
23973 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23977 wxPyEndAllowThreads(__tstate);
23978 if (PyErr_Occurred()) SWIG_fail;
23979 }
23980 {
23981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23982 }
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23990 PyObject *resultobj = 0;
23991 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23992 bool result;
23993 void *argp1 = 0 ;
23994 int res1 = 0 ;
23995 PyObject *swig_obj[1] ;
23996
23997 if (!args) SWIG_fail;
23998 swig_obj[0] = args;
23999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24000 if (!SWIG_IsOK(res1)) {
24001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24002 }
24003 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24004 {
24005 PyThreadState* __tstate = wxPyBeginAllowThreads();
24006 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
24007 wxPyEndAllowThreads(__tstate);
24008 if (PyErr_Occurred()) SWIG_fail;
24009 }
24010 {
24011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24012 }
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 PyObject *resultobj = 0;
24021 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24022 bool result;
24023 void *argp1 = 0 ;
24024 int res1 = 0 ;
24025 PyObject *swig_obj[1] ;
24026
24027 if (!args) SWIG_fail;
24028 swig_obj[0] = args;
24029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24030 if (!SWIG_IsOK(res1)) {
24031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24032 }
24033 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
24037 wxPyEndAllowThreads(__tstate);
24038 if (PyErr_Occurred()) SWIG_fail;
24039 }
24040 {
24041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24042 }
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24050 PyObject *resultobj = 0;
24051 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24052 bool result;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 PyObject *swig_obj[1] ;
24056
24057 if (!args) SWIG_fail;
24058 swig_obj[0] = args;
24059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24060 if (!SWIG_IsOK(res1)) {
24061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24062 }
24063 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (bool)(arg1)->LeftIsDown();
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 {
24071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24072 }
24073 return resultobj;
24074 fail:
24075 return NULL;
24076 }
24077
24078
24079 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24080 PyObject *resultobj = 0;
24081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24082 bool result;
24083 void *argp1 = 0 ;
24084 int res1 = 0 ;
24085 PyObject *swig_obj[1] ;
24086
24087 if (!args) SWIG_fail;
24088 swig_obj[0] = args;
24089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24090 if (!SWIG_IsOK(res1)) {
24091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24092 }
24093 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24094 {
24095 PyThreadState* __tstate = wxPyBeginAllowThreads();
24096 result = (bool)(arg1)->MiddleIsDown();
24097 wxPyEndAllowThreads(__tstate);
24098 if (PyErr_Occurred()) SWIG_fail;
24099 }
24100 {
24101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24102 }
24103 return resultobj;
24104 fail:
24105 return NULL;
24106 }
24107
24108
24109 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24110 PyObject *resultobj = 0;
24111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24112 bool result;
24113 void *argp1 = 0 ;
24114 int res1 = 0 ;
24115 PyObject *swig_obj[1] ;
24116
24117 if (!args) SWIG_fail;
24118 swig_obj[0] = args;
24119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24120 if (!SWIG_IsOK(res1)) {
24121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24122 }
24123 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 result = (bool)(arg1)->RightIsDown();
24127 wxPyEndAllowThreads(__tstate);
24128 if (PyErr_Occurred()) SWIG_fail;
24129 }
24130 {
24131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24132 }
24133 return resultobj;
24134 fail:
24135 return NULL;
24136 }
24137
24138
24139 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24140 PyObject *resultobj = 0;
24141 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24142 bool result;
24143 void *argp1 = 0 ;
24144 int res1 = 0 ;
24145 PyObject *swig_obj[1] ;
24146
24147 if (!args) SWIG_fail;
24148 swig_obj[0] = args;
24149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24150 if (!SWIG_IsOK(res1)) {
24151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24152 }
24153 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24154 {
24155 PyThreadState* __tstate = wxPyBeginAllowThreads();
24156 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
24157 wxPyEndAllowThreads(__tstate);
24158 if (PyErr_Occurred()) SWIG_fail;
24159 }
24160 {
24161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24162 }
24163 return resultobj;
24164 fail:
24165 return NULL;
24166 }
24167
24168
24169 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24170 PyObject *resultobj = 0;
24171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24172 bool result;
24173 void *argp1 = 0 ;
24174 int res1 = 0 ;
24175 PyObject *swig_obj[1] ;
24176
24177 if (!args) SWIG_fail;
24178 swig_obj[0] = args;
24179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24180 if (!SWIG_IsOK(res1)) {
24181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24182 }
24183 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24184 {
24185 PyThreadState* __tstate = wxPyBeginAllowThreads();
24186 result = (bool)((wxMouseEvent const *)arg1)->Moving();
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 {
24191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24192 }
24193 return resultobj;
24194 fail:
24195 return NULL;
24196 }
24197
24198
24199 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24200 PyObject *resultobj = 0;
24201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24202 bool result;
24203 void *argp1 = 0 ;
24204 int res1 = 0 ;
24205 PyObject *swig_obj[1] ;
24206
24207 if (!args) SWIG_fail;
24208 swig_obj[0] = args;
24209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24210 if (!SWIG_IsOK(res1)) {
24211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24212 }
24213 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 result = (bool)((wxMouseEvent const *)arg1)->Entering();
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 {
24221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24222 }
24223 return resultobj;
24224 fail:
24225 return NULL;
24226 }
24227
24228
24229 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24230 PyObject *resultobj = 0;
24231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24232 bool result;
24233 void *argp1 = 0 ;
24234 int res1 = 0 ;
24235 PyObject *swig_obj[1] ;
24236
24237 if (!args) SWIG_fail;
24238 swig_obj[0] = args;
24239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24240 if (!SWIG_IsOK(res1)) {
24241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24242 }
24243 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24244 {
24245 PyThreadState* __tstate = wxPyBeginAllowThreads();
24246 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
24247 wxPyEndAllowThreads(__tstate);
24248 if (PyErr_Occurred()) SWIG_fail;
24249 }
24250 {
24251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24252 }
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24260 PyObject *resultobj = 0;
24261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24262 wxPoint result;
24263 void *argp1 = 0 ;
24264 int res1 = 0 ;
24265 PyObject *swig_obj[1] ;
24266
24267 if (!args) SWIG_fail;
24268 swig_obj[0] = args;
24269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24270 if (!SWIG_IsOK(res1)) {
24271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24272 }
24273 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24274 {
24275 PyThreadState* __tstate = wxPyBeginAllowThreads();
24276 result = (arg1)->GetPosition();
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24281 return resultobj;
24282 fail:
24283 return NULL;
24284 }
24285
24286
24287 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24288 PyObject *resultobj = 0;
24289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24290 long *arg2 = (long *) 0 ;
24291 long *arg3 = (long *) 0 ;
24292 void *argp1 = 0 ;
24293 int res1 = 0 ;
24294 long temp2 ;
24295 int res2 = SWIG_TMPOBJ ;
24296 long temp3 ;
24297 int res3 = SWIG_TMPOBJ ;
24298 PyObject *swig_obj[1] ;
24299
24300 arg2 = &temp2;
24301 arg3 = &temp3;
24302 if (!args) SWIG_fail;
24303 swig_obj[0] = args;
24304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24307 }
24308 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24309 {
24310 PyThreadState* __tstate = wxPyBeginAllowThreads();
24311 (arg1)->GetPosition(arg2,arg3);
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 resultobj = SWIG_Py_Void();
24316 if (SWIG_IsTmpObj(res2)) {
24317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
24318 } else {
24319 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
24321 }
24322 if (SWIG_IsTmpObj(res3)) {
24323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
24324 } else {
24325 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
24327 }
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24335 PyObject *resultobj = 0;
24336 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24337 wxDC *arg2 = 0 ;
24338 wxPoint result;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 void *argp2 = 0 ;
24342 int res2 = 0 ;
24343 PyObject * obj0 = 0 ;
24344 PyObject * obj1 = 0 ;
24345 char * kwnames[] = {
24346 (char *) "self",(char *) "dc", NULL
24347 };
24348
24349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24351 if (!SWIG_IsOK(res1)) {
24352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24353 }
24354 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
24356 if (!SWIG_IsOK(res2)) {
24357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24358 }
24359 if (!argp2) {
24360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24361 }
24362 arg2 = reinterpret_cast< wxDC * >(argp2);
24363 {
24364 PyThreadState* __tstate = wxPyBeginAllowThreads();
24365 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
24366 wxPyEndAllowThreads(__tstate);
24367 if (PyErr_Occurred()) SWIG_fail;
24368 }
24369 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24370 return resultobj;
24371 fail:
24372 return NULL;
24373 }
24374
24375
24376 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24377 PyObject *resultobj = 0;
24378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24379 int result;
24380 void *argp1 = 0 ;
24381 int res1 = 0 ;
24382 PyObject *swig_obj[1] ;
24383
24384 if (!args) SWIG_fail;
24385 swig_obj[0] = args;
24386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24387 if (!SWIG_IsOK(res1)) {
24388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24389 }
24390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24391 {
24392 PyThreadState* __tstate = wxPyBeginAllowThreads();
24393 result = (int)((wxMouseEvent const *)arg1)->GetX();
24394 wxPyEndAllowThreads(__tstate);
24395 if (PyErr_Occurred()) SWIG_fail;
24396 }
24397 resultobj = SWIG_From_int(static_cast< int >(result));
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *resultobj = 0;
24406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24407 int result;
24408 void *argp1 = 0 ;
24409 int res1 = 0 ;
24410 PyObject *swig_obj[1] ;
24411
24412 if (!args) SWIG_fail;
24413 swig_obj[0] = args;
24414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24415 if (!SWIG_IsOK(res1)) {
24416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24417 }
24418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24419 {
24420 PyThreadState* __tstate = wxPyBeginAllowThreads();
24421 result = (int)((wxMouseEvent const *)arg1)->GetY();
24422 wxPyEndAllowThreads(__tstate);
24423 if (PyErr_Occurred()) SWIG_fail;
24424 }
24425 resultobj = SWIG_From_int(static_cast< int >(result));
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24433 PyObject *resultobj = 0;
24434 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24435 int result;
24436 void *argp1 = 0 ;
24437 int res1 = 0 ;
24438 PyObject *swig_obj[1] ;
24439
24440 if (!args) SWIG_fail;
24441 swig_obj[0] = args;
24442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24443 if (!SWIG_IsOK(res1)) {
24444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24445 }
24446 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24447 {
24448 PyThreadState* __tstate = wxPyBeginAllowThreads();
24449 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
24450 wxPyEndAllowThreads(__tstate);
24451 if (PyErr_Occurred()) SWIG_fail;
24452 }
24453 resultobj = SWIG_From_int(static_cast< int >(result));
24454 return resultobj;
24455 fail:
24456 return NULL;
24457 }
24458
24459
24460 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24461 PyObject *resultobj = 0;
24462 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24463 int result;
24464 void *argp1 = 0 ;
24465 int res1 = 0 ;
24466 PyObject *swig_obj[1] ;
24467
24468 if (!args) SWIG_fail;
24469 swig_obj[0] = args;
24470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24471 if (!SWIG_IsOK(res1)) {
24472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24473 }
24474 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 resultobj = SWIG_From_int(static_cast< int >(result));
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24489 PyObject *resultobj = 0;
24490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24491 int result;
24492 void *argp1 = 0 ;
24493 int res1 = 0 ;
24494 PyObject *swig_obj[1] ;
24495
24496 if (!args) SWIG_fail;
24497 swig_obj[0] = args;
24498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24499 if (!SWIG_IsOK(res1)) {
24500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24501 }
24502 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24503 {
24504 PyThreadState* __tstate = wxPyBeginAllowThreads();
24505 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
24506 wxPyEndAllowThreads(__tstate);
24507 if (PyErr_Occurred()) SWIG_fail;
24508 }
24509 resultobj = SWIG_From_int(static_cast< int >(result));
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24517 PyObject *resultobj = 0;
24518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24519 int result;
24520 void *argp1 = 0 ;
24521 int res1 = 0 ;
24522 PyObject *swig_obj[1] ;
24523
24524 if (!args) SWIG_fail;
24525 swig_obj[0] = args;
24526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24527 if (!SWIG_IsOK(res1)) {
24528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24529 }
24530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24531 {
24532 PyThreadState* __tstate = wxPyBeginAllowThreads();
24533 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24534 wxPyEndAllowThreads(__tstate);
24535 if (PyErr_Occurred()) SWIG_fail;
24536 }
24537 resultobj = SWIG_From_int(static_cast< int >(result));
24538 return resultobj;
24539 fail:
24540 return NULL;
24541 }
24542
24543
24544 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24545 PyObject *resultobj = 0;
24546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24547 bool result;
24548 void *argp1 = 0 ;
24549 int res1 = 0 ;
24550 PyObject *swig_obj[1] ;
24551
24552 if (!args) SWIG_fail;
24553 swig_obj[0] = args;
24554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24555 if (!SWIG_IsOK(res1)) {
24556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24557 }
24558 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24559 {
24560 PyThreadState* __tstate = wxPyBeginAllowThreads();
24561 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 {
24566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24567 }
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24575 PyObject *resultobj = 0;
24576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24577 int arg2 ;
24578 void *argp1 = 0 ;
24579 int res1 = 0 ;
24580 int val2 ;
24581 int ecode2 = 0 ;
24582 PyObject *swig_obj[2] ;
24583
24584 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24586 if (!SWIG_IsOK(res1)) {
24587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24588 }
24589 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24590 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24591 if (!SWIG_IsOK(ecode2)) {
24592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24593 }
24594 arg2 = static_cast< int >(val2);
24595 if (arg1) (arg1)->m_x = arg2;
24596
24597 resultobj = SWIG_Py_Void();
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24605 PyObject *resultobj = 0;
24606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24607 int result;
24608 void *argp1 = 0 ;
24609 int res1 = 0 ;
24610 PyObject *swig_obj[1] ;
24611
24612 if (!args) SWIG_fail;
24613 swig_obj[0] = args;
24614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24615 if (!SWIG_IsOK(res1)) {
24616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24617 }
24618 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24619 result = (int) ((arg1)->m_x);
24620 resultobj = SWIG_From_int(static_cast< int >(result));
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24628 PyObject *resultobj = 0;
24629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24630 int arg2 ;
24631 void *argp1 = 0 ;
24632 int res1 = 0 ;
24633 int val2 ;
24634 int ecode2 = 0 ;
24635 PyObject *swig_obj[2] ;
24636
24637 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24639 if (!SWIG_IsOK(res1)) {
24640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24641 }
24642 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24643 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24644 if (!SWIG_IsOK(ecode2)) {
24645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24646 }
24647 arg2 = static_cast< int >(val2);
24648 if (arg1) (arg1)->m_y = arg2;
24649
24650 resultobj = SWIG_Py_Void();
24651 return resultobj;
24652 fail:
24653 return NULL;
24654 }
24655
24656
24657 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24658 PyObject *resultobj = 0;
24659 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24660 int result;
24661 void *argp1 = 0 ;
24662 int res1 = 0 ;
24663 PyObject *swig_obj[1] ;
24664
24665 if (!args) SWIG_fail;
24666 swig_obj[0] = args;
24667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24668 if (!SWIG_IsOK(res1)) {
24669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24670 }
24671 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24672 result = (int) ((arg1)->m_y);
24673 resultobj = SWIG_From_int(static_cast< int >(result));
24674 return resultobj;
24675 fail:
24676 return NULL;
24677 }
24678
24679
24680 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24681 PyObject *resultobj = 0;
24682 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24683 bool arg2 ;
24684 void *argp1 = 0 ;
24685 int res1 = 0 ;
24686 bool val2 ;
24687 int ecode2 = 0 ;
24688 PyObject *swig_obj[2] ;
24689
24690 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24692 if (!SWIG_IsOK(res1)) {
24693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24694 }
24695 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24696 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24697 if (!SWIG_IsOK(ecode2)) {
24698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24699 }
24700 arg2 = static_cast< bool >(val2);
24701 if (arg1) (arg1)->m_leftDown = arg2;
24702
24703 resultobj = SWIG_Py_Void();
24704 return resultobj;
24705 fail:
24706 return NULL;
24707 }
24708
24709
24710 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24711 PyObject *resultobj = 0;
24712 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24713 bool result;
24714 void *argp1 = 0 ;
24715 int res1 = 0 ;
24716 PyObject *swig_obj[1] ;
24717
24718 if (!args) SWIG_fail;
24719 swig_obj[0] = args;
24720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24721 if (!SWIG_IsOK(res1)) {
24722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24723 }
24724 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24725 result = (bool) ((arg1)->m_leftDown);
24726 {
24727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24728 }
24729 return resultobj;
24730 fail:
24731 return NULL;
24732 }
24733
24734
24735 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24736 PyObject *resultobj = 0;
24737 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24738 bool arg2 ;
24739 void *argp1 = 0 ;
24740 int res1 = 0 ;
24741 bool val2 ;
24742 int ecode2 = 0 ;
24743 PyObject *swig_obj[2] ;
24744
24745 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24747 if (!SWIG_IsOK(res1)) {
24748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24749 }
24750 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24751 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24752 if (!SWIG_IsOK(ecode2)) {
24753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24754 }
24755 arg2 = static_cast< bool >(val2);
24756 if (arg1) (arg1)->m_middleDown = arg2;
24757
24758 resultobj = SWIG_Py_Void();
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24766 PyObject *resultobj = 0;
24767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24768 bool result;
24769 void *argp1 = 0 ;
24770 int res1 = 0 ;
24771 PyObject *swig_obj[1] ;
24772
24773 if (!args) SWIG_fail;
24774 swig_obj[0] = args;
24775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24776 if (!SWIG_IsOK(res1)) {
24777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24778 }
24779 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24780 result = (bool) ((arg1)->m_middleDown);
24781 {
24782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24783 }
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24791 PyObject *resultobj = 0;
24792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24793 bool arg2 ;
24794 void *argp1 = 0 ;
24795 int res1 = 0 ;
24796 bool val2 ;
24797 int ecode2 = 0 ;
24798 PyObject *swig_obj[2] ;
24799
24800 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24802 if (!SWIG_IsOK(res1)) {
24803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24804 }
24805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24806 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24807 if (!SWIG_IsOK(ecode2)) {
24808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24809 }
24810 arg2 = static_cast< bool >(val2);
24811 if (arg1) (arg1)->m_rightDown = arg2;
24812
24813 resultobj = SWIG_Py_Void();
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24821 PyObject *resultobj = 0;
24822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24823 bool result;
24824 void *argp1 = 0 ;
24825 int res1 = 0 ;
24826 PyObject *swig_obj[1] ;
24827
24828 if (!args) SWIG_fail;
24829 swig_obj[0] = args;
24830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24831 if (!SWIG_IsOK(res1)) {
24832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24833 }
24834 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24835 result = (bool) ((arg1)->m_rightDown);
24836 {
24837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24838 }
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24846 PyObject *resultobj = 0;
24847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24848 bool arg2 ;
24849 void *argp1 = 0 ;
24850 int res1 = 0 ;
24851 bool val2 ;
24852 int ecode2 = 0 ;
24853 PyObject *swig_obj[2] ;
24854
24855 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24859 }
24860 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24861 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24862 if (!SWIG_IsOK(ecode2)) {
24863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24864 }
24865 arg2 = static_cast< bool >(val2);
24866 if (arg1) (arg1)->m_controlDown = arg2;
24867
24868 resultobj = SWIG_Py_Void();
24869 return resultobj;
24870 fail:
24871 return NULL;
24872 }
24873
24874
24875 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24876 PyObject *resultobj = 0;
24877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24878 bool result;
24879 void *argp1 = 0 ;
24880 int res1 = 0 ;
24881 PyObject *swig_obj[1] ;
24882
24883 if (!args) SWIG_fail;
24884 swig_obj[0] = args;
24885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24886 if (!SWIG_IsOK(res1)) {
24887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24888 }
24889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24890 result = (bool) ((arg1)->m_controlDown);
24891 {
24892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24893 }
24894 return resultobj;
24895 fail:
24896 return NULL;
24897 }
24898
24899
24900 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24901 PyObject *resultobj = 0;
24902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24903 bool arg2 ;
24904 void *argp1 = 0 ;
24905 int res1 = 0 ;
24906 bool val2 ;
24907 int ecode2 = 0 ;
24908 PyObject *swig_obj[2] ;
24909
24910 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24912 if (!SWIG_IsOK(res1)) {
24913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24914 }
24915 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24916 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24917 if (!SWIG_IsOK(ecode2)) {
24918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24919 }
24920 arg2 = static_cast< bool >(val2);
24921 if (arg1) (arg1)->m_shiftDown = arg2;
24922
24923 resultobj = SWIG_Py_Void();
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24931 PyObject *resultobj = 0;
24932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24933 bool result;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 PyObject *swig_obj[1] ;
24937
24938 if (!args) SWIG_fail;
24939 swig_obj[0] = args;
24940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24941 if (!SWIG_IsOK(res1)) {
24942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24943 }
24944 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24945 result = (bool) ((arg1)->m_shiftDown);
24946 {
24947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24948 }
24949 return resultobj;
24950 fail:
24951 return NULL;
24952 }
24953
24954
24955 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24956 PyObject *resultobj = 0;
24957 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24958 bool arg2 ;
24959 void *argp1 = 0 ;
24960 int res1 = 0 ;
24961 bool val2 ;
24962 int ecode2 = 0 ;
24963 PyObject *swig_obj[2] ;
24964
24965 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24967 if (!SWIG_IsOK(res1)) {
24968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24969 }
24970 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24971 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24972 if (!SWIG_IsOK(ecode2)) {
24973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24974 }
24975 arg2 = static_cast< bool >(val2);
24976 if (arg1) (arg1)->m_altDown = arg2;
24977
24978 resultobj = SWIG_Py_Void();
24979 return resultobj;
24980 fail:
24981 return NULL;
24982 }
24983
24984
24985 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24986 PyObject *resultobj = 0;
24987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24988 bool result;
24989 void *argp1 = 0 ;
24990 int res1 = 0 ;
24991 PyObject *swig_obj[1] ;
24992
24993 if (!args) SWIG_fail;
24994 swig_obj[0] = args;
24995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24996 if (!SWIG_IsOK(res1)) {
24997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24998 }
24999 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25000 result = (bool) ((arg1)->m_altDown);
25001 {
25002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25003 }
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25011 PyObject *resultobj = 0;
25012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25013 bool arg2 ;
25014 void *argp1 = 0 ;
25015 int res1 = 0 ;
25016 bool val2 ;
25017 int ecode2 = 0 ;
25018 PyObject *swig_obj[2] ;
25019
25020 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25022 if (!SWIG_IsOK(res1)) {
25023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25024 }
25025 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25026 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25027 if (!SWIG_IsOK(ecode2)) {
25028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25029 }
25030 arg2 = static_cast< bool >(val2);
25031 if (arg1) (arg1)->m_metaDown = arg2;
25032
25033 resultobj = SWIG_Py_Void();
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25041 PyObject *resultobj = 0;
25042 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25043 bool result;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 PyObject *swig_obj[1] ;
25047
25048 if (!args) SWIG_fail;
25049 swig_obj[0] = args;
25050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25053 }
25054 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25055 result = (bool) ((arg1)->m_metaDown);
25056 {
25057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25058 }
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25066 PyObject *resultobj = 0;
25067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25068 int arg2 ;
25069 void *argp1 = 0 ;
25070 int res1 = 0 ;
25071 int val2 ;
25072 int ecode2 = 0 ;
25073 PyObject *swig_obj[2] ;
25074
25075 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
25076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25077 if (!SWIG_IsOK(res1)) {
25078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25079 }
25080 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25081 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25082 if (!SWIG_IsOK(ecode2)) {
25083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
25084 }
25085 arg2 = static_cast< int >(val2);
25086 if (arg1) (arg1)->m_wheelRotation = arg2;
25087
25088 resultobj = SWIG_Py_Void();
25089 return resultobj;
25090 fail:
25091 return NULL;
25092 }
25093
25094
25095 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25096 PyObject *resultobj = 0;
25097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25098 int result;
25099 void *argp1 = 0 ;
25100 int res1 = 0 ;
25101 PyObject *swig_obj[1] ;
25102
25103 if (!args) SWIG_fail;
25104 swig_obj[0] = args;
25105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25106 if (!SWIG_IsOK(res1)) {
25107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25108 }
25109 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25110 result = (int) ((arg1)->m_wheelRotation);
25111 resultobj = SWIG_From_int(static_cast< int >(result));
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25119 PyObject *resultobj = 0;
25120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25121 int arg2 ;
25122 void *argp1 = 0 ;
25123 int res1 = 0 ;
25124 int val2 ;
25125 int ecode2 = 0 ;
25126 PyObject *swig_obj[2] ;
25127
25128 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
25129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25130 if (!SWIG_IsOK(res1)) {
25131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25132 }
25133 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25134 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25135 if (!SWIG_IsOK(ecode2)) {
25136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
25137 }
25138 arg2 = static_cast< int >(val2);
25139 if (arg1) (arg1)->m_wheelDelta = arg2;
25140
25141 resultobj = SWIG_Py_Void();
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25149 PyObject *resultobj = 0;
25150 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25151 int result;
25152 void *argp1 = 0 ;
25153 int res1 = 0 ;
25154 PyObject *swig_obj[1] ;
25155
25156 if (!args) SWIG_fail;
25157 swig_obj[0] = args;
25158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25159 if (!SWIG_IsOK(res1)) {
25160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25161 }
25162 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25163 result = (int) ((arg1)->m_wheelDelta);
25164 resultobj = SWIG_From_int(static_cast< int >(result));
25165 return resultobj;
25166 fail:
25167 return NULL;
25168 }
25169
25170
25171 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25172 PyObject *resultobj = 0;
25173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25174 int arg2 ;
25175 void *argp1 = 0 ;
25176 int res1 = 0 ;
25177 int val2 ;
25178 int ecode2 = 0 ;
25179 PyObject *swig_obj[2] ;
25180
25181 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
25182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25183 if (!SWIG_IsOK(res1)) {
25184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25185 }
25186 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25187 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25188 if (!SWIG_IsOK(ecode2)) {
25189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
25190 }
25191 arg2 = static_cast< int >(val2);
25192 if (arg1) (arg1)->m_linesPerAction = arg2;
25193
25194 resultobj = SWIG_Py_Void();
25195 return resultobj;
25196 fail:
25197 return NULL;
25198 }
25199
25200
25201 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25202 PyObject *resultobj = 0;
25203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25204 int result;
25205 void *argp1 = 0 ;
25206 int res1 = 0 ;
25207 PyObject *swig_obj[1] ;
25208
25209 if (!args) SWIG_fail;
25210 swig_obj[0] = args;
25211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25212 if (!SWIG_IsOK(res1)) {
25213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25214 }
25215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25216 result = (int) ((arg1)->m_linesPerAction);
25217 resultobj = SWIG_From_int(static_cast< int >(result));
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25225 PyObject *obj;
25226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25227 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
25228 return SWIG_Py_Void();
25229 }
25230
25231 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25232 return SWIG_Python_InitShadowInstance(args);
25233 }
25234
25235 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25236 PyObject *resultobj = 0;
25237 int arg1 = (int) 0 ;
25238 int arg2 = (int) 0 ;
25239 wxSetCursorEvent *result = 0 ;
25240 int val1 ;
25241 int ecode1 = 0 ;
25242 int val2 ;
25243 int ecode2 = 0 ;
25244 PyObject * obj0 = 0 ;
25245 PyObject * obj1 = 0 ;
25246 char * kwnames[] = {
25247 (char *) "x",(char *) "y", NULL
25248 };
25249
25250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25251 if (obj0) {
25252 ecode1 = SWIG_AsVal_int(obj0, &val1);
25253 if (!SWIG_IsOK(ecode1)) {
25254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
25255 }
25256 arg1 = static_cast< int >(val1);
25257 }
25258 if (obj1) {
25259 ecode2 = SWIG_AsVal_int(obj1, &val2);
25260 if (!SWIG_IsOK(ecode2)) {
25261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
25262 }
25263 arg2 = static_cast< int >(val2);
25264 }
25265 {
25266 PyThreadState* __tstate = wxPyBeginAllowThreads();
25267 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
25272 return resultobj;
25273 fail:
25274 return NULL;
25275 }
25276
25277
25278 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25279 PyObject *resultobj = 0;
25280 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25281 int result;
25282 void *argp1 = 0 ;
25283 int res1 = 0 ;
25284 PyObject *swig_obj[1] ;
25285
25286 if (!args) SWIG_fail;
25287 swig_obj[0] = args;
25288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25289 if (!SWIG_IsOK(res1)) {
25290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25291 }
25292 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25293 {
25294 PyThreadState* __tstate = wxPyBeginAllowThreads();
25295 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 resultobj = SWIG_From_int(static_cast< int >(result));
25300 return resultobj;
25301 fail:
25302 return NULL;
25303 }
25304
25305
25306 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25307 PyObject *resultobj = 0;
25308 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25309 int result;
25310 void *argp1 = 0 ;
25311 int res1 = 0 ;
25312 PyObject *swig_obj[1] ;
25313
25314 if (!args) SWIG_fail;
25315 swig_obj[0] = args;
25316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25317 if (!SWIG_IsOK(res1)) {
25318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25319 }
25320 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
25324 wxPyEndAllowThreads(__tstate);
25325 if (PyErr_Occurred()) SWIG_fail;
25326 }
25327 resultobj = SWIG_From_int(static_cast< int >(result));
25328 return resultobj;
25329 fail:
25330 return NULL;
25331 }
25332
25333
25334 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj = 0;
25336 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25337 wxCursor *arg2 = 0 ;
25338 void *argp1 = 0 ;
25339 int res1 = 0 ;
25340 void *argp2 = 0 ;
25341 int res2 = 0 ;
25342 PyObject * obj0 = 0 ;
25343 PyObject * obj1 = 0 ;
25344 char * kwnames[] = {
25345 (char *) "self",(char *) "cursor", NULL
25346 };
25347
25348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
25349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25350 if (!SWIG_IsOK(res1)) {
25351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
25352 }
25353 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25354 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
25355 if (!SWIG_IsOK(res2)) {
25356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25357 }
25358 if (!argp2) {
25359 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25360 }
25361 arg2 = reinterpret_cast< wxCursor * >(argp2);
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 (arg1)->SetCursor((wxCursor const &)*arg2);
25365 wxPyEndAllowThreads(__tstate);
25366 if (PyErr_Occurred()) SWIG_fail;
25367 }
25368 resultobj = SWIG_Py_Void();
25369 return resultobj;
25370 fail:
25371 return NULL;
25372 }
25373
25374
25375 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25376 PyObject *resultobj = 0;
25377 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25378 wxCursor *result = 0 ;
25379 void *argp1 = 0 ;
25380 int res1 = 0 ;
25381 PyObject *swig_obj[1] ;
25382
25383 if (!args) SWIG_fail;
25384 swig_obj[0] = args;
25385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25386 if (!SWIG_IsOK(res1)) {
25387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25388 }
25389 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25390 {
25391 PyThreadState* __tstate = wxPyBeginAllowThreads();
25392 {
25393 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
25394 result = (wxCursor *) &_result_ref;
25395 }
25396 wxPyEndAllowThreads(__tstate);
25397 if (PyErr_Occurred()) SWIG_fail;
25398 }
25399 {
25400 wxCursor* resultptr = new wxCursor(*result);
25401 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
25402 }
25403 return resultobj;
25404 fail:
25405 return NULL;
25406 }
25407
25408
25409 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25410 PyObject *resultobj = 0;
25411 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25412 bool result;
25413 void *argp1 = 0 ;
25414 int res1 = 0 ;
25415 PyObject *swig_obj[1] ;
25416
25417 if (!args) SWIG_fail;
25418 swig_obj[0] = args;
25419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25420 if (!SWIG_IsOK(res1)) {
25421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25422 }
25423 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25424 {
25425 PyThreadState* __tstate = wxPyBeginAllowThreads();
25426 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
25427 wxPyEndAllowThreads(__tstate);
25428 if (PyErr_Occurred()) SWIG_fail;
25429 }
25430 {
25431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25432 }
25433 return resultobj;
25434 fail:
25435 return NULL;
25436 }
25437
25438
25439 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25440 PyObject *obj;
25441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25442 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
25443 return SWIG_Py_Void();
25444 }
25445
25446 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25447 return SWIG_Python_InitShadowInstance(args);
25448 }
25449
25450 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25451 PyObject *resultobj = 0;
25452 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25453 wxKeyEvent *result = 0 ;
25454 int val1 ;
25455 int ecode1 = 0 ;
25456 PyObject * obj0 = 0 ;
25457 char * kwnames[] = {
25458 (char *) "eventType", NULL
25459 };
25460
25461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
25462 if (obj0) {
25463 ecode1 = SWIG_AsVal_int(obj0, &val1);
25464 if (!SWIG_IsOK(ecode1)) {
25465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
25466 }
25467 arg1 = static_cast< wxEventType >(val1);
25468 }
25469 {
25470 PyThreadState* __tstate = wxPyBeginAllowThreads();
25471 result = (wxKeyEvent *)new wxKeyEvent(arg1);
25472 wxPyEndAllowThreads(__tstate);
25473 if (PyErr_Occurred()) SWIG_fail;
25474 }
25475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25483 PyObject *resultobj = 0;
25484 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25485 int result;
25486 void *argp1 = 0 ;
25487 int res1 = 0 ;
25488 PyObject *swig_obj[1] ;
25489
25490 if (!args) SWIG_fail;
25491 swig_obj[0] = args;
25492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25493 if (!SWIG_IsOK(res1)) {
25494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25495 }
25496 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25497 {
25498 PyThreadState* __tstate = wxPyBeginAllowThreads();
25499 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
25500 wxPyEndAllowThreads(__tstate);
25501 if (PyErr_Occurred()) SWIG_fail;
25502 }
25503 resultobj = SWIG_From_int(static_cast< int >(result));
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25511 PyObject *resultobj = 0;
25512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25513 bool result;
25514 void *argp1 = 0 ;
25515 int res1 = 0 ;
25516 PyObject *swig_obj[1] ;
25517
25518 if (!args) SWIG_fail;
25519 swig_obj[0] = args;
25520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25521 if (!SWIG_IsOK(res1)) {
25522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25523 }
25524 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25525 {
25526 PyThreadState* __tstate = wxPyBeginAllowThreads();
25527 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25528 wxPyEndAllowThreads(__tstate);
25529 if (PyErr_Occurred()) SWIG_fail;
25530 }
25531 {
25532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25533 }
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25543 bool result;
25544 void *argp1 = 0 ;
25545 int res1 = 0 ;
25546 PyObject *swig_obj[1] ;
25547
25548 if (!args) SWIG_fail;
25549 swig_obj[0] = args;
25550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25551 if (!SWIG_IsOK(res1)) {
25552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25553 }
25554 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25555 {
25556 PyThreadState* __tstate = wxPyBeginAllowThreads();
25557 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25558 wxPyEndAllowThreads(__tstate);
25559 if (PyErr_Occurred()) SWIG_fail;
25560 }
25561 {
25562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25563 }
25564 return resultobj;
25565 fail:
25566 return NULL;
25567 }
25568
25569
25570 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25571 PyObject *resultobj = 0;
25572 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25573 bool result;
25574 void *argp1 = 0 ;
25575 int res1 = 0 ;
25576 PyObject *swig_obj[1] ;
25577
25578 if (!args) SWIG_fail;
25579 swig_obj[0] = args;
25580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25581 if (!SWIG_IsOK(res1)) {
25582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25583 }
25584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25585 {
25586 PyThreadState* __tstate = wxPyBeginAllowThreads();
25587 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 {
25592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25593 }
25594 return resultobj;
25595 fail:
25596 return NULL;
25597 }
25598
25599
25600 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25601 PyObject *resultobj = 0;
25602 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25603 bool result;
25604 void *argp1 = 0 ;
25605 int res1 = 0 ;
25606 PyObject *swig_obj[1] ;
25607
25608 if (!args) SWIG_fail;
25609 swig_obj[0] = args;
25610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25611 if (!SWIG_IsOK(res1)) {
25612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25613 }
25614 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 {
25622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25623 }
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25631 PyObject *resultobj = 0;
25632 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25633 bool result;
25634 void *argp1 = 0 ;
25635 int res1 = 0 ;
25636 PyObject *swig_obj[1] ;
25637
25638 if (!args) SWIG_fail;
25639 swig_obj[0] = args;
25640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25641 if (!SWIG_IsOK(res1)) {
25642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25643 }
25644 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25648 wxPyEndAllowThreads(__tstate);
25649 if (PyErr_Occurred()) SWIG_fail;
25650 }
25651 {
25652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25653 }
25654 return resultobj;
25655 fail:
25656 return NULL;
25657 }
25658
25659
25660 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25661 PyObject *resultobj = 0;
25662 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25663 bool result;
25664 void *argp1 = 0 ;
25665 int res1 = 0 ;
25666 PyObject *swig_obj[1] ;
25667
25668 if (!args) SWIG_fail;
25669 swig_obj[0] = args;
25670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25671 if (!SWIG_IsOK(res1)) {
25672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25673 }
25674 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25675 {
25676 PyThreadState* __tstate = wxPyBeginAllowThreads();
25677 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25678 wxPyEndAllowThreads(__tstate);
25679 if (PyErr_Occurred()) SWIG_fail;
25680 }
25681 {
25682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25683 }
25684 return resultobj;
25685 fail:
25686 return NULL;
25687 }
25688
25689
25690 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25691 PyObject *resultobj = 0;
25692 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25693 int result;
25694 void *argp1 = 0 ;
25695 int res1 = 0 ;
25696 PyObject *swig_obj[1] ;
25697
25698 if (!args) SWIG_fail;
25699 swig_obj[0] = args;
25700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25701 if (!SWIG_IsOK(res1)) {
25702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25703 }
25704 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25705 {
25706 PyThreadState* __tstate = wxPyBeginAllowThreads();
25707 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25708 wxPyEndAllowThreads(__tstate);
25709 if (PyErr_Occurred()) SWIG_fail;
25710 }
25711 resultobj = SWIG_From_int(static_cast< int >(result));
25712 return resultobj;
25713 fail:
25714 return NULL;
25715 }
25716
25717
25718 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25719 PyObject *resultobj = 0;
25720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25721 int result;
25722 void *argp1 = 0 ;
25723 int res1 = 0 ;
25724 PyObject *swig_obj[1] ;
25725
25726 if (!args) SWIG_fail;
25727 swig_obj[0] = args;
25728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25729 if (!SWIG_IsOK(res1)) {
25730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25731 }
25732 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25733 {
25734 PyThreadState* __tstate = wxPyBeginAllowThreads();
25735 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25736 wxPyEndAllowThreads(__tstate);
25737 if (PyErr_Occurred()) SWIG_fail;
25738 }
25739 resultobj = SWIG_From_int(static_cast< int >(result));
25740 return resultobj;
25741 fail:
25742 return NULL;
25743 }
25744
25745
25746 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25747 PyObject *resultobj = 0;
25748 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25749 int arg2 ;
25750 void *argp1 = 0 ;
25751 int res1 = 0 ;
25752 int val2 ;
25753 int ecode2 = 0 ;
25754 PyObject * obj0 = 0 ;
25755 PyObject * obj1 = 0 ;
25756 char * kwnames[] = {
25757 (char *) "self",(char *) "uniChar", NULL
25758 };
25759
25760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25762 if (!SWIG_IsOK(res1)) {
25763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25764 }
25765 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25766 ecode2 = SWIG_AsVal_int(obj1, &val2);
25767 if (!SWIG_IsOK(ecode2)) {
25768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25769 }
25770 arg2 = static_cast< int >(val2);
25771 {
25772 PyThreadState* __tstate = wxPyBeginAllowThreads();
25773 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25774 wxPyEndAllowThreads(__tstate);
25775 if (PyErr_Occurred()) SWIG_fail;
25776 }
25777 resultobj = SWIG_Py_Void();
25778 return resultobj;
25779 fail:
25780 return NULL;
25781 }
25782
25783
25784 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25785 PyObject *resultobj = 0;
25786 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25787 unsigned int result;
25788 void *argp1 = 0 ;
25789 int res1 = 0 ;
25790 PyObject *swig_obj[1] ;
25791
25792 if (!args) SWIG_fail;
25793 swig_obj[0] = args;
25794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25795 if (!SWIG_IsOK(res1)) {
25796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25797 }
25798 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25799 {
25800 PyThreadState* __tstate = wxPyBeginAllowThreads();
25801 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25802 wxPyEndAllowThreads(__tstate);
25803 if (PyErr_Occurred()) SWIG_fail;
25804 }
25805 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25813 PyObject *resultobj = 0;
25814 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25815 unsigned int result;
25816 void *argp1 = 0 ;
25817 int res1 = 0 ;
25818 PyObject *swig_obj[1] ;
25819
25820 if (!args) SWIG_fail;
25821 swig_obj[0] = args;
25822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25823 if (!SWIG_IsOK(res1)) {
25824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25825 }
25826 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25827 {
25828 PyThreadState* __tstate = wxPyBeginAllowThreads();
25829 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25830 wxPyEndAllowThreads(__tstate);
25831 if (PyErr_Occurred()) SWIG_fail;
25832 }
25833 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25834 return resultobj;
25835 fail:
25836 return NULL;
25837 }
25838
25839
25840 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25841 PyObject *resultobj = 0;
25842 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25843 wxPoint result;
25844 void *argp1 = 0 ;
25845 int res1 = 0 ;
25846 PyObject *swig_obj[1] ;
25847
25848 if (!args) SWIG_fail;
25849 swig_obj[0] = args;
25850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25851 if (!SWIG_IsOK(res1)) {
25852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25853 }
25854 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25855 {
25856 PyThreadState* __tstate = wxPyBeginAllowThreads();
25857 result = (arg1)->GetPosition();
25858 wxPyEndAllowThreads(__tstate);
25859 if (PyErr_Occurred()) SWIG_fail;
25860 }
25861 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25869 PyObject *resultobj = 0;
25870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25871 long *arg2 = (long *) 0 ;
25872 long *arg3 = (long *) 0 ;
25873 void *argp1 = 0 ;
25874 int res1 = 0 ;
25875 long temp2 ;
25876 int res2 = SWIG_TMPOBJ ;
25877 long temp3 ;
25878 int res3 = SWIG_TMPOBJ ;
25879 PyObject *swig_obj[1] ;
25880
25881 arg2 = &temp2;
25882 arg3 = &temp3;
25883 if (!args) SWIG_fail;
25884 swig_obj[0] = args;
25885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25886 if (!SWIG_IsOK(res1)) {
25887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25888 }
25889 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 (arg1)->GetPosition(arg2,arg3);
25893 wxPyEndAllowThreads(__tstate);
25894 if (PyErr_Occurred()) SWIG_fail;
25895 }
25896 resultobj = SWIG_Py_Void();
25897 if (SWIG_IsTmpObj(res2)) {
25898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25899 } else {
25900 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25902 }
25903 if (SWIG_IsTmpObj(res3)) {
25904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25905 } else {
25906 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25908 }
25909 return resultobj;
25910 fail:
25911 return NULL;
25912 }
25913
25914
25915 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25916 PyObject *resultobj = 0;
25917 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25918 int result;
25919 void *argp1 = 0 ;
25920 int res1 = 0 ;
25921 PyObject *swig_obj[1] ;
25922
25923 if (!args) SWIG_fail;
25924 swig_obj[0] = args;
25925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25926 if (!SWIG_IsOK(res1)) {
25927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25928 }
25929 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25930 {
25931 PyThreadState* __tstate = wxPyBeginAllowThreads();
25932 result = (int)((wxKeyEvent const *)arg1)->GetX();
25933 wxPyEndAllowThreads(__tstate);
25934 if (PyErr_Occurred()) SWIG_fail;
25935 }
25936 resultobj = SWIG_From_int(static_cast< int >(result));
25937 return resultobj;
25938 fail:
25939 return NULL;
25940 }
25941
25942
25943 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25944 PyObject *resultobj = 0;
25945 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25946 int result;
25947 void *argp1 = 0 ;
25948 int res1 = 0 ;
25949 PyObject *swig_obj[1] ;
25950
25951 if (!args) SWIG_fail;
25952 swig_obj[0] = args;
25953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25954 if (!SWIG_IsOK(res1)) {
25955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25956 }
25957 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 result = (int)((wxKeyEvent const *)arg1)->GetY();
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 resultobj = SWIG_From_int(static_cast< int >(result));
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25972 PyObject *resultobj = 0;
25973 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25974 int arg2 ;
25975 void *argp1 = 0 ;
25976 int res1 = 0 ;
25977 int val2 ;
25978 int ecode2 = 0 ;
25979 PyObject *swig_obj[2] ;
25980
25981 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25983 if (!SWIG_IsOK(res1)) {
25984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25985 }
25986 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25987 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25988 if (!SWIG_IsOK(ecode2)) {
25989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25990 }
25991 arg2 = static_cast< int >(val2);
25992 if (arg1) (arg1)->m_x = arg2;
25993
25994 resultobj = SWIG_Py_Void();
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26002 PyObject *resultobj = 0;
26003 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26004 int result;
26005 void *argp1 = 0 ;
26006 int res1 = 0 ;
26007 PyObject *swig_obj[1] ;
26008
26009 if (!args) SWIG_fail;
26010 swig_obj[0] = args;
26011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26012 if (!SWIG_IsOK(res1)) {
26013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26014 }
26015 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26016 result = (int) ((arg1)->m_x);
26017 resultobj = SWIG_From_int(static_cast< int >(result));
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26025 PyObject *resultobj = 0;
26026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26027 int arg2 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 int val2 ;
26031 int ecode2 = 0 ;
26032 PyObject *swig_obj[2] ;
26033
26034 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
26035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26036 if (!SWIG_IsOK(res1)) {
26037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26038 }
26039 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26040 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26041 if (!SWIG_IsOK(ecode2)) {
26042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
26043 }
26044 arg2 = static_cast< int >(val2);
26045 if (arg1) (arg1)->m_y = arg2;
26046
26047 resultobj = SWIG_Py_Void();
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26055 PyObject *resultobj = 0;
26056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26057 int result;
26058 void *argp1 = 0 ;
26059 int res1 = 0 ;
26060 PyObject *swig_obj[1] ;
26061
26062 if (!args) SWIG_fail;
26063 swig_obj[0] = args;
26064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26065 if (!SWIG_IsOK(res1)) {
26066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26067 }
26068 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26069 result = (int) ((arg1)->m_y);
26070 resultobj = SWIG_From_int(static_cast< int >(result));
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26078 PyObject *resultobj = 0;
26079 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26080 long arg2 ;
26081 void *argp1 = 0 ;
26082 int res1 = 0 ;
26083 long val2 ;
26084 int ecode2 = 0 ;
26085 PyObject *swig_obj[2] ;
26086
26087 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
26088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26089 if (!SWIG_IsOK(res1)) {
26090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26091 }
26092 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26093 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
26094 if (!SWIG_IsOK(ecode2)) {
26095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
26096 }
26097 arg2 = static_cast< long >(val2);
26098 if (arg1) (arg1)->m_keyCode = arg2;
26099
26100 resultobj = SWIG_Py_Void();
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *resultobj = 0;
26109 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26110 long result;
26111 void *argp1 = 0 ;
26112 int res1 = 0 ;
26113 PyObject *swig_obj[1] ;
26114
26115 if (!args) SWIG_fail;
26116 swig_obj[0] = args;
26117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26118 if (!SWIG_IsOK(res1)) {
26119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26120 }
26121 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26122 result = (long) ((arg1)->m_keyCode);
26123 resultobj = SWIG_From_long(static_cast< long >(result));
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26131 PyObject *resultobj = 0;
26132 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26133 bool arg2 ;
26134 void *argp1 = 0 ;
26135 int res1 = 0 ;
26136 bool val2 ;
26137 int ecode2 = 0 ;
26138 PyObject *swig_obj[2] ;
26139
26140 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
26141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26142 if (!SWIG_IsOK(res1)) {
26143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26144 }
26145 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26146 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26147 if (!SWIG_IsOK(ecode2)) {
26148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
26149 }
26150 arg2 = static_cast< bool >(val2);
26151 if (arg1) (arg1)->m_controlDown = arg2;
26152
26153 resultobj = SWIG_Py_Void();
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26161 PyObject *resultobj = 0;
26162 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26163 bool result;
26164 void *argp1 = 0 ;
26165 int res1 = 0 ;
26166 PyObject *swig_obj[1] ;
26167
26168 if (!args) SWIG_fail;
26169 swig_obj[0] = args;
26170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26171 if (!SWIG_IsOK(res1)) {
26172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26173 }
26174 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26175 result = (bool) ((arg1)->m_controlDown);
26176 {
26177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26178 }
26179 return resultobj;
26180 fail:
26181 return NULL;
26182 }
26183
26184
26185 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26186 PyObject *resultobj = 0;
26187 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26188 bool arg2 ;
26189 void *argp1 = 0 ;
26190 int res1 = 0 ;
26191 bool val2 ;
26192 int ecode2 = 0 ;
26193 PyObject *swig_obj[2] ;
26194
26195 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
26196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26197 if (!SWIG_IsOK(res1)) {
26198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26199 }
26200 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26201 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26202 if (!SWIG_IsOK(ecode2)) {
26203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
26204 }
26205 arg2 = static_cast< bool >(val2);
26206 if (arg1) (arg1)->m_shiftDown = arg2;
26207
26208 resultobj = SWIG_Py_Void();
26209 return resultobj;
26210 fail:
26211 return NULL;
26212 }
26213
26214
26215 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26216 PyObject *resultobj = 0;
26217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26218 bool result;
26219 void *argp1 = 0 ;
26220 int res1 = 0 ;
26221 PyObject *swig_obj[1] ;
26222
26223 if (!args) SWIG_fail;
26224 swig_obj[0] = args;
26225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26226 if (!SWIG_IsOK(res1)) {
26227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26228 }
26229 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26230 result = (bool) ((arg1)->m_shiftDown);
26231 {
26232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26233 }
26234 return resultobj;
26235 fail:
26236 return NULL;
26237 }
26238
26239
26240 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26241 PyObject *resultobj = 0;
26242 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26243 bool arg2 ;
26244 void *argp1 = 0 ;
26245 int res1 = 0 ;
26246 bool val2 ;
26247 int ecode2 = 0 ;
26248 PyObject *swig_obj[2] ;
26249
26250 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
26251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26252 if (!SWIG_IsOK(res1)) {
26253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26254 }
26255 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26256 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26257 if (!SWIG_IsOK(ecode2)) {
26258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
26259 }
26260 arg2 = static_cast< bool >(val2);
26261 if (arg1) (arg1)->m_altDown = arg2;
26262
26263 resultobj = SWIG_Py_Void();
26264 return resultobj;
26265 fail:
26266 return NULL;
26267 }
26268
26269
26270 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26271 PyObject *resultobj = 0;
26272 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26273 bool result;
26274 void *argp1 = 0 ;
26275 int res1 = 0 ;
26276 PyObject *swig_obj[1] ;
26277
26278 if (!args) SWIG_fail;
26279 swig_obj[0] = args;
26280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26281 if (!SWIG_IsOK(res1)) {
26282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26283 }
26284 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26285 result = (bool) ((arg1)->m_altDown);
26286 {
26287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26288 }
26289 return resultobj;
26290 fail:
26291 return NULL;
26292 }
26293
26294
26295 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26296 PyObject *resultobj = 0;
26297 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26298 bool arg2 ;
26299 void *argp1 = 0 ;
26300 int res1 = 0 ;
26301 bool val2 ;
26302 int ecode2 = 0 ;
26303 PyObject *swig_obj[2] ;
26304
26305 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
26306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26307 if (!SWIG_IsOK(res1)) {
26308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26309 }
26310 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26311 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26312 if (!SWIG_IsOK(ecode2)) {
26313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
26314 }
26315 arg2 = static_cast< bool >(val2);
26316 if (arg1) (arg1)->m_metaDown = arg2;
26317
26318 resultobj = SWIG_Py_Void();
26319 return resultobj;
26320 fail:
26321 return NULL;
26322 }
26323
26324
26325 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26326 PyObject *resultobj = 0;
26327 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26328 bool result;
26329 void *argp1 = 0 ;
26330 int res1 = 0 ;
26331 PyObject *swig_obj[1] ;
26332
26333 if (!args) SWIG_fail;
26334 swig_obj[0] = args;
26335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26336 if (!SWIG_IsOK(res1)) {
26337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26338 }
26339 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26340 result = (bool) ((arg1)->m_metaDown);
26341 {
26342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26343 }
26344 return resultobj;
26345 fail:
26346 return NULL;
26347 }
26348
26349
26350 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26351 PyObject *resultobj = 0;
26352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26353 bool arg2 ;
26354 void *argp1 = 0 ;
26355 int res1 = 0 ;
26356 bool val2 ;
26357 int ecode2 = 0 ;
26358 PyObject *swig_obj[2] ;
26359
26360 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
26361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26362 if (!SWIG_IsOK(res1)) {
26363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26364 }
26365 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26366 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26367 if (!SWIG_IsOK(ecode2)) {
26368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
26369 }
26370 arg2 = static_cast< bool >(val2);
26371 if (arg1) (arg1)->m_scanCode = arg2;
26372
26373 resultobj = SWIG_Py_Void();
26374 return resultobj;
26375 fail:
26376 return NULL;
26377 }
26378
26379
26380 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26381 PyObject *resultobj = 0;
26382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26383 bool result;
26384 void *argp1 = 0 ;
26385 int res1 = 0 ;
26386 PyObject *swig_obj[1] ;
26387
26388 if (!args) SWIG_fail;
26389 swig_obj[0] = args;
26390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26391 if (!SWIG_IsOK(res1)) {
26392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26393 }
26394 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26395 result = (bool) ((arg1)->m_scanCode);
26396 {
26397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26398 }
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26406 PyObject *resultobj = 0;
26407 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26408 unsigned int arg2 ;
26409 void *argp1 = 0 ;
26410 int res1 = 0 ;
26411 unsigned int val2 ;
26412 int ecode2 = 0 ;
26413 PyObject *swig_obj[2] ;
26414
26415 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
26416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26417 if (!SWIG_IsOK(res1)) {
26418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26419 }
26420 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26421 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26422 if (!SWIG_IsOK(ecode2)) {
26423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
26424 }
26425 arg2 = static_cast< unsigned int >(val2);
26426 if (arg1) (arg1)->m_rawCode = arg2;
26427
26428 resultobj = SWIG_Py_Void();
26429 return resultobj;
26430 fail:
26431 return NULL;
26432 }
26433
26434
26435 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26436 PyObject *resultobj = 0;
26437 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26438 unsigned int result;
26439 void *argp1 = 0 ;
26440 int res1 = 0 ;
26441 PyObject *swig_obj[1] ;
26442
26443 if (!args) SWIG_fail;
26444 swig_obj[0] = args;
26445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26446 if (!SWIG_IsOK(res1)) {
26447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26448 }
26449 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26450 result = (unsigned int) ((arg1)->m_rawCode);
26451 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26452 return resultobj;
26453 fail:
26454 return NULL;
26455 }
26456
26457
26458 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26459 PyObject *resultobj = 0;
26460 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26461 unsigned int arg2 ;
26462 void *argp1 = 0 ;
26463 int res1 = 0 ;
26464 unsigned int val2 ;
26465 int ecode2 = 0 ;
26466 PyObject *swig_obj[2] ;
26467
26468 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
26469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26470 if (!SWIG_IsOK(res1)) {
26471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26472 }
26473 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26474 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26475 if (!SWIG_IsOK(ecode2)) {
26476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
26477 }
26478 arg2 = static_cast< unsigned int >(val2);
26479 if (arg1) (arg1)->m_rawFlags = arg2;
26480
26481 resultobj = SWIG_Py_Void();
26482 return resultobj;
26483 fail:
26484 return NULL;
26485 }
26486
26487
26488 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26489 PyObject *resultobj = 0;
26490 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26491 unsigned int result;
26492 void *argp1 = 0 ;
26493 int res1 = 0 ;
26494 PyObject *swig_obj[1] ;
26495
26496 if (!args) SWIG_fail;
26497 swig_obj[0] = args;
26498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26499 if (!SWIG_IsOK(res1)) {
26500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26501 }
26502 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26503 result = (unsigned int) ((arg1)->m_rawFlags);
26504 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26505 return resultobj;
26506 fail:
26507 return NULL;
26508 }
26509
26510
26511 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26512 PyObject *obj;
26513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26514 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
26515 return SWIG_Py_Void();
26516 }
26517
26518 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26519 return SWIG_Python_InitShadowInstance(args);
26520 }
26521
26522 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj = 0;
26524 wxSize const &arg1_defvalue = wxDefaultSize ;
26525 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26526 int arg2 = (int) 0 ;
26527 wxSizeEvent *result = 0 ;
26528 wxSize temp1 ;
26529 int val2 ;
26530 int ecode2 = 0 ;
26531 PyObject * obj0 = 0 ;
26532 PyObject * obj1 = 0 ;
26533 char * kwnames[] = {
26534 (char *) "sz",(char *) "winid", NULL
26535 };
26536
26537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26538 if (obj0) {
26539 {
26540 arg1 = &temp1;
26541 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26542 }
26543 }
26544 if (obj1) {
26545 ecode2 = SWIG_AsVal_int(obj1, &val2);
26546 if (!SWIG_IsOK(ecode2)) {
26547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26548 }
26549 arg2 = static_cast< int >(val2);
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *resultobj = 0;
26566 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26567 wxSize result;
26568 void *argp1 = 0 ;
26569 int res1 = 0 ;
26570 PyObject *swig_obj[1] ;
26571
26572 if (!args) SWIG_fail;
26573 swig_obj[0] = args;
26574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26575 if (!SWIG_IsOK(res1)) {
26576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26577 }
26578 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26579 {
26580 PyThreadState* __tstate = wxPyBeginAllowThreads();
26581 result = ((wxSizeEvent const *)arg1)->GetSize();
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26593 PyObject *resultobj = 0;
26594 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26595 wxRect result;
26596 void *argp1 = 0 ;
26597 int res1 = 0 ;
26598 PyObject *swig_obj[1] ;
26599
26600 if (!args) SWIG_fail;
26601 swig_obj[0] = args;
26602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26603 if (!SWIG_IsOK(res1)) {
26604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26605 }
26606 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = ((wxSizeEvent const *)arg1)->GetRect();
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26614 return resultobj;
26615 fail:
26616 return NULL;
26617 }
26618
26619
26620 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26621 PyObject *resultobj = 0;
26622 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26623 wxRect arg2 ;
26624 void *argp1 = 0 ;
26625 int res1 = 0 ;
26626 void *argp2 ;
26627 int res2 = 0 ;
26628 PyObject * obj0 = 0 ;
26629 PyObject * obj1 = 0 ;
26630 char * kwnames[] = {
26631 (char *) "self",(char *) "rect", NULL
26632 };
26633
26634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26636 if (!SWIG_IsOK(res1)) {
26637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26638 }
26639 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26640 {
26641 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26642 if (!SWIG_IsOK(res2)) {
26643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26644 }
26645 if (!argp2) {
26646 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26647 } else {
26648 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26649 arg2 = *temp;
26650 if (SWIG_IsNewObj(res2)) delete temp;
26651 }
26652 }
26653 {
26654 PyThreadState* __tstate = wxPyBeginAllowThreads();
26655 (arg1)->SetRect(arg2);
26656 wxPyEndAllowThreads(__tstate);
26657 if (PyErr_Occurred()) SWIG_fail;
26658 }
26659 resultobj = SWIG_Py_Void();
26660 return resultobj;
26661 fail:
26662 return NULL;
26663 }
26664
26665
26666 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26667 PyObject *resultobj = 0;
26668 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26669 wxSize arg2 ;
26670 void *argp1 = 0 ;
26671 int res1 = 0 ;
26672 void *argp2 ;
26673 int res2 = 0 ;
26674 PyObject * obj0 = 0 ;
26675 PyObject * obj1 = 0 ;
26676 char * kwnames[] = {
26677 (char *) "self",(char *) "size", NULL
26678 };
26679
26680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26682 if (!SWIG_IsOK(res1)) {
26683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26684 }
26685 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26686 {
26687 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26688 if (!SWIG_IsOK(res2)) {
26689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26690 }
26691 if (!argp2) {
26692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26693 } else {
26694 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26695 arg2 = *temp;
26696 if (SWIG_IsNewObj(res2)) delete temp;
26697 }
26698 }
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 wxSizeEvent_SetSize(arg1,arg2);
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 resultobj = SWIG_Py_Void();
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26713 PyObject *resultobj = 0;
26714 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26715 wxSize *arg2 = (wxSize *) 0 ;
26716 void *argp1 = 0 ;
26717 int res1 = 0 ;
26718 void *argp2 = 0 ;
26719 int res2 = 0 ;
26720 PyObject *swig_obj[2] ;
26721
26722 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26724 if (!SWIG_IsOK(res1)) {
26725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26726 }
26727 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26728 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26729 if (!SWIG_IsOK(res2)) {
26730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26731 }
26732 arg2 = reinterpret_cast< wxSize * >(argp2);
26733 if (arg1) (arg1)->m_size = *arg2;
26734
26735 resultobj = SWIG_Py_Void();
26736 return resultobj;
26737 fail:
26738 return NULL;
26739 }
26740
26741
26742 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26743 PyObject *resultobj = 0;
26744 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26745 wxSize *result = 0 ;
26746 void *argp1 = 0 ;
26747 int res1 = 0 ;
26748 PyObject *swig_obj[1] ;
26749
26750 if (!args) SWIG_fail;
26751 swig_obj[0] = args;
26752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26753 if (!SWIG_IsOK(res1)) {
26754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26755 }
26756 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26757 result = (wxSize *)& ((arg1)->m_size);
26758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26766 PyObject *resultobj = 0;
26767 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26768 wxRect *arg2 = (wxRect *) 0 ;
26769 void *argp1 = 0 ;
26770 int res1 = 0 ;
26771 void *argp2 = 0 ;
26772 int res2 = 0 ;
26773 PyObject *swig_obj[2] ;
26774
26775 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26777 if (!SWIG_IsOK(res1)) {
26778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26779 }
26780 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26781 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26782 if (!SWIG_IsOK(res2)) {
26783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26784 }
26785 arg2 = reinterpret_cast< wxRect * >(argp2);
26786 if (arg1) (arg1)->m_rect = *arg2;
26787
26788 resultobj = SWIG_Py_Void();
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26796 PyObject *resultobj = 0;
26797 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26798 wxRect *result = 0 ;
26799 void *argp1 = 0 ;
26800 int res1 = 0 ;
26801 PyObject *swig_obj[1] ;
26802
26803 if (!args) SWIG_fail;
26804 swig_obj[0] = args;
26805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26806 if (!SWIG_IsOK(res1)) {
26807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26808 }
26809 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26810 result = (wxRect *)& ((arg1)->m_rect);
26811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26812 return resultobj;
26813 fail:
26814 return NULL;
26815 }
26816
26817
26818 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26819 PyObject *obj;
26820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26821 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26822 return SWIG_Py_Void();
26823 }
26824
26825 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26826 return SWIG_Python_InitShadowInstance(args);
26827 }
26828
26829 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26830 PyObject *resultobj = 0;
26831 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26832 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26833 int arg2 = (int) 0 ;
26834 wxMoveEvent *result = 0 ;
26835 wxPoint temp1 ;
26836 int val2 ;
26837 int ecode2 = 0 ;
26838 PyObject * obj0 = 0 ;
26839 PyObject * obj1 = 0 ;
26840 char * kwnames[] = {
26841 (char *) "pos",(char *) "winid", NULL
26842 };
26843
26844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26845 if (obj0) {
26846 {
26847 arg1 = &temp1;
26848 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26849 }
26850 }
26851 if (obj1) {
26852 ecode2 = SWIG_AsVal_int(obj1, &val2);
26853 if (!SWIG_IsOK(ecode2)) {
26854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26855 }
26856 arg2 = static_cast< int >(val2);
26857 }
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 PyObject *resultobj = 0;
26873 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26874 wxPoint result;
26875 void *argp1 = 0 ;
26876 int res1 = 0 ;
26877 PyObject *swig_obj[1] ;
26878
26879 if (!args) SWIG_fail;
26880 swig_obj[0] = args;
26881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26882 if (!SWIG_IsOK(res1)) {
26883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26884 }
26885 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 result = ((wxMoveEvent const *)arg1)->GetPosition();
26889 wxPyEndAllowThreads(__tstate);
26890 if (PyErr_Occurred()) SWIG_fail;
26891 }
26892 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26893 return resultobj;
26894 fail:
26895 return NULL;
26896 }
26897
26898
26899 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26900 PyObject *resultobj = 0;
26901 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26902 wxRect result;
26903 void *argp1 = 0 ;
26904 int res1 = 0 ;
26905 PyObject *swig_obj[1] ;
26906
26907 if (!args) SWIG_fail;
26908 swig_obj[0] = args;
26909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26910 if (!SWIG_IsOK(res1)) {
26911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26912 }
26913 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26914 {
26915 PyThreadState* __tstate = wxPyBeginAllowThreads();
26916 result = ((wxMoveEvent const *)arg1)->GetRect();
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26921 return resultobj;
26922 fail:
26923 return NULL;
26924 }
26925
26926
26927 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26928 PyObject *resultobj = 0;
26929 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26930 wxRect *arg2 = 0 ;
26931 void *argp1 = 0 ;
26932 int res1 = 0 ;
26933 wxRect temp2 ;
26934 PyObject * obj0 = 0 ;
26935 PyObject * obj1 = 0 ;
26936 char * kwnames[] = {
26937 (char *) "self",(char *) "rect", NULL
26938 };
26939
26940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26942 if (!SWIG_IsOK(res1)) {
26943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26944 }
26945 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26946 {
26947 arg2 = &temp2;
26948 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26949 }
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 (arg1)->SetRect((wxRect const &)*arg2);
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 resultobj = SWIG_Py_Void();
26957 return resultobj;
26958 fail:
26959 return NULL;
26960 }
26961
26962
26963 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26964 PyObject *resultobj = 0;
26965 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26966 wxPoint *arg2 = 0 ;
26967 void *argp1 = 0 ;
26968 int res1 = 0 ;
26969 wxPoint temp2 ;
26970 PyObject * obj0 = 0 ;
26971 PyObject * obj1 = 0 ;
26972 char * kwnames[] = {
26973 (char *) "self",(char *) "pos", NULL
26974 };
26975
26976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26978 if (!SWIG_IsOK(res1)) {
26979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26980 }
26981 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26982 {
26983 arg2 = &temp2;
26984 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26985 }
26986 {
26987 PyThreadState* __tstate = wxPyBeginAllowThreads();
26988 (arg1)->SetPosition((wxPoint const &)*arg2);
26989 wxPyEndAllowThreads(__tstate);
26990 if (PyErr_Occurred()) SWIG_fail;
26991 }
26992 resultobj = SWIG_Py_Void();
26993 return resultobj;
26994 fail:
26995 return NULL;
26996 }
26997
26998
26999 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27000 PyObject *obj;
27001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27002 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
27003 return SWIG_Py_Void();
27004 }
27005
27006 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27007 return SWIG_Python_InitShadowInstance(args);
27008 }
27009
27010 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27011 PyObject *resultobj = 0;
27012 int arg1 = (int) 0 ;
27013 wxPaintEvent *result = 0 ;
27014 int val1 ;
27015 int ecode1 = 0 ;
27016 PyObject * obj0 = 0 ;
27017 char * kwnames[] = {
27018 (char *) "Id", NULL
27019 };
27020
27021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
27022 if (obj0) {
27023 ecode1 = SWIG_AsVal_int(obj0, &val1);
27024 if (!SWIG_IsOK(ecode1)) {
27025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
27026 }
27027 arg1 = static_cast< int >(val1);
27028 }
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 result = (wxPaintEvent *)new wxPaintEvent(arg1);
27032 wxPyEndAllowThreads(__tstate);
27033 if (PyErr_Occurred()) SWIG_fail;
27034 }
27035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
27036 return resultobj;
27037 fail:
27038 return NULL;
27039 }
27040
27041
27042 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27043 PyObject *obj;
27044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27045 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
27046 return SWIG_Py_Void();
27047 }
27048
27049 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27050 return SWIG_Python_InitShadowInstance(args);
27051 }
27052
27053 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27054 PyObject *resultobj = 0;
27055 int arg1 = (int) 0 ;
27056 wxNcPaintEvent *result = 0 ;
27057 int val1 ;
27058 int ecode1 = 0 ;
27059 PyObject * obj0 = 0 ;
27060 char * kwnames[] = {
27061 (char *) "winid", NULL
27062 };
27063
27064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
27065 if (obj0) {
27066 ecode1 = SWIG_AsVal_int(obj0, &val1);
27067 if (!SWIG_IsOK(ecode1)) {
27068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
27069 }
27070 arg1 = static_cast< int >(val1);
27071 }
27072 {
27073 PyThreadState* __tstate = wxPyBeginAllowThreads();
27074 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
27075 wxPyEndAllowThreads(__tstate);
27076 if (PyErr_Occurred()) SWIG_fail;
27077 }
27078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
27079 return resultobj;
27080 fail:
27081 return NULL;
27082 }
27083
27084
27085 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27086 PyObject *obj;
27087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27088 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
27089 return SWIG_Py_Void();
27090 }
27091
27092 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27093 return SWIG_Python_InitShadowInstance(args);
27094 }
27095
27096 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj = 0;
27098 int arg1 = (int) 0 ;
27099 wxDC *arg2 = (wxDC *) NULL ;
27100 wxEraseEvent *result = 0 ;
27101 int val1 ;
27102 int ecode1 = 0 ;
27103 void *argp2 = 0 ;
27104 int res2 = 0 ;
27105 PyObject * obj0 = 0 ;
27106 PyObject * obj1 = 0 ;
27107 char * kwnames[] = {
27108 (char *) "Id",(char *) "dc", NULL
27109 };
27110
27111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27112 if (obj0) {
27113 ecode1 = SWIG_AsVal_int(obj0, &val1);
27114 if (!SWIG_IsOK(ecode1)) {
27115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
27116 }
27117 arg1 = static_cast< int >(val1);
27118 }
27119 if (obj1) {
27120 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
27121 if (!SWIG_IsOK(res2)) {
27122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
27123 }
27124 arg2 = reinterpret_cast< wxDC * >(argp2);
27125 }
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
27129 wxPyEndAllowThreads(__tstate);
27130 if (PyErr_Occurred()) SWIG_fail;
27131 }
27132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
27133 return resultobj;
27134 fail:
27135 return NULL;
27136 }
27137
27138
27139 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27140 PyObject *resultobj = 0;
27141 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
27142 wxDC *result = 0 ;
27143 void *argp1 = 0 ;
27144 int res1 = 0 ;
27145 PyObject *swig_obj[1] ;
27146
27147 if (!args) SWIG_fail;
27148 swig_obj[0] = args;
27149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
27150 if (!SWIG_IsOK(res1)) {
27151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
27152 }
27153 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
27154 {
27155 PyThreadState* __tstate = wxPyBeginAllowThreads();
27156 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
27157 wxPyEndAllowThreads(__tstate);
27158 if (PyErr_Occurred()) SWIG_fail;
27159 }
27160 {
27161 resultobj = wxPyMake_wxObject(result, (bool)0);
27162 }
27163 return resultobj;
27164 fail:
27165 return NULL;
27166 }
27167
27168
27169 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27170 PyObject *obj;
27171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27172 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
27173 return SWIG_Py_Void();
27174 }
27175
27176 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27177 return SWIG_Python_InitShadowInstance(args);
27178 }
27179
27180 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj = 0;
27182 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27183 int arg2 = (int) 0 ;
27184 wxFocusEvent *result = 0 ;
27185 int val1 ;
27186 int ecode1 = 0 ;
27187 int val2 ;
27188 int ecode2 = 0 ;
27189 PyObject * obj0 = 0 ;
27190 PyObject * obj1 = 0 ;
27191 char * kwnames[] = {
27192 (char *) "type",(char *) "winid", NULL
27193 };
27194
27195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27196 if (obj0) {
27197 ecode1 = SWIG_AsVal_int(obj0, &val1);
27198 if (!SWIG_IsOK(ecode1)) {
27199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27200 }
27201 arg1 = static_cast< wxEventType >(val1);
27202 }
27203 if (obj1) {
27204 ecode2 = SWIG_AsVal_int(obj1, &val2);
27205 if (!SWIG_IsOK(ecode2)) {
27206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
27207 }
27208 arg2 = static_cast< int >(val2);
27209 }
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27224 PyObject *resultobj = 0;
27225 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27226 wxWindow *result = 0 ;
27227 void *argp1 = 0 ;
27228 int res1 = 0 ;
27229 PyObject *swig_obj[1] ;
27230
27231 if (!args) SWIG_fail;
27232 swig_obj[0] = args;
27233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27234 if (!SWIG_IsOK(res1)) {
27235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
27236 }
27237 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27238 {
27239 PyThreadState* __tstate = wxPyBeginAllowThreads();
27240 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
27241 wxPyEndAllowThreads(__tstate);
27242 if (PyErr_Occurred()) SWIG_fail;
27243 }
27244 {
27245 resultobj = wxPyMake_wxObject(result, (bool)0);
27246 }
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj = 0;
27255 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27256 wxWindow *arg2 = (wxWindow *) 0 ;
27257 void *argp1 = 0 ;
27258 int res1 = 0 ;
27259 void *argp2 = 0 ;
27260 int res2 = 0 ;
27261 PyObject * obj0 = 0 ;
27262 PyObject * obj1 = 0 ;
27263 char * kwnames[] = {
27264 (char *) "self",(char *) "win", NULL
27265 };
27266
27267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27269 if (!SWIG_IsOK(res1)) {
27270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
27271 }
27272 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27274 if (!SWIG_IsOK(res2)) {
27275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27276 }
27277 arg2 = reinterpret_cast< wxWindow * >(argp2);
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 (arg1)->SetWindow(arg2);
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 resultobj = SWIG_Py_Void();
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27292 PyObject *obj;
27293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27294 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
27295 return SWIG_Py_Void();
27296 }
27297
27298 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27299 return SWIG_Python_InitShadowInstance(args);
27300 }
27301
27302 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27303 PyObject *resultobj = 0;
27304 wxWindow *arg1 = (wxWindow *) NULL ;
27305 wxChildFocusEvent *result = 0 ;
27306 void *argp1 = 0 ;
27307 int res1 = 0 ;
27308 PyObject * obj0 = 0 ;
27309 char * kwnames[] = {
27310 (char *) "win", NULL
27311 };
27312
27313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
27314 if (obj0) {
27315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27316 if (!SWIG_IsOK(res1)) {
27317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27318 }
27319 arg1 = reinterpret_cast< wxWindow * >(argp1);
27320 }
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
27324 wxPyEndAllowThreads(__tstate);
27325 if (PyErr_Occurred()) SWIG_fail;
27326 }
27327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
27328 return resultobj;
27329 fail:
27330 return NULL;
27331 }
27332
27333
27334 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27335 PyObject *resultobj = 0;
27336 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
27337 wxWindow *result = 0 ;
27338 void *argp1 = 0 ;
27339 int res1 = 0 ;
27340 PyObject *swig_obj[1] ;
27341
27342 if (!args) SWIG_fail;
27343 swig_obj[0] = args;
27344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
27345 if (!SWIG_IsOK(res1)) {
27346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
27347 }
27348 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
27349 {
27350 PyThreadState* __tstate = wxPyBeginAllowThreads();
27351 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
27352 wxPyEndAllowThreads(__tstate);
27353 if (PyErr_Occurred()) SWIG_fail;
27354 }
27355 {
27356 resultobj = wxPyMake_wxObject(result, (bool)0);
27357 }
27358 return resultobj;
27359 fail:
27360 return NULL;
27361 }
27362
27363
27364 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27365 PyObject *obj;
27366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27367 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
27368 return SWIG_Py_Void();
27369 }
27370
27371 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27372 return SWIG_Python_InitShadowInstance(args);
27373 }
27374
27375 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj = 0;
27377 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27378 bool arg2 = (bool) true ;
27379 int arg3 = (int) 0 ;
27380 wxActivateEvent *result = 0 ;
27381 int val1 ;
27382 int ecode1 = 0 ;
27383 bool val2 ;
27384 int ecode2 = 0 ;
27385 int val3 ;
27386 int ecode3 = 0 ;
27387 PyObject * obj0 = 0 ;
27388 PyObject * obj1 = 0 ;
27389 PyObject * obj2 = 0 ;
27390 char * kwnames[] = {
27391 (char *) "type",(char *) "active",(char *) "Id", NULL
27392 };
27393
27394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27395 if (obj0) {
27396 ecode1 = SWIG_AsVal_int(obj0, &val1);
27397 if (!SWIG_IsOK(ecode1)) {
27398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27399 }
27400 arg1 = static_cast< wxEventType >(val1);
27401 }
27402 if (obj1) {
27403 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27404 if (!SWIG_IsOK(ecode2)) {
27405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
27406 }
27407 arg2 = static_cast< bool >(val2);
27408 }
27409 if (obj2) {
27410 ecode3 = SWIG_AsVal_int(obj2, &val3);
27411 if (!SWIG_IsOK(ecode3)) {
27412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
27413 }
27414 arg3 = static_cast< int >(val3);
27415 }
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
27419 wxPyEndAllowThreads(__tstate);
27420 if (PyErr_Occurred()) SWIG_fail;
27421 }
27422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27430 PyObject *resultobj = 0;
27431 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
27432 bool result;
27433 void *argp1 = 0 ;
27434 int res1 = 0 ;
27435 PyObject *swig_obj[1] ;
27436
27437 if (!args) SWIG_fail;
27438 swig_obj[0] = args;
27439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
27440 if (!SWIG_IsOK(res1)) {
27441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
27442 }
27443 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
27444 {
27445 PyThreadState* __tstate = wxPyBeginAllowThreads();
27446 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 {
27451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27452 }
27453 return resultobj;
27454 fail:
27455 return NULL;
27456 }
27457
27458
27459 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27460 PyObject *obj;
27461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27462 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
27463 return SWIG_Py_Void();
27464 }
27465
27466 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27467 return SWIG_Python_InitShadowInstance(args);
27468 }
27469
27470 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27471 PyObject *resultobj = 0;
27472 int arg1 = (int) 0 ;
27473 wxInitDialogEvent *result = 0 ;
27474 int val1 ;
27475 int ecode1 = 0 ;
27476 PyObject * obj0 = 0 ;
27477 char * kwnames[] = {
27478 (char *) "Id", NULL
27479 };
27480
27481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
27482 if (obj0) {
27483 ecode1 = SWIG_AsVal_int(obj0, &val1);
27484 if (!SWIG_IsOK(ecode1)) {
27485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
27486 }
27487 arg1 = static_cast< int >(val1);
27488 }
27489 {
27490 PyThreadState* __tstate = wxPyBeginAllowThreads();
27491 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
27492 wxPyEndAllowThreads(__tstate);
27493 if (PyErr_Occurred()) SWIG_fail;
27494 }
27495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
27496 return resultobj;
27497 fail:
27498 return NULL;
27499 }
27500
27501
27502 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27503 PyObject *obj;
27504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27505 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
27506 return SWIG_Py_Void();
27507 }
27508
27509 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27510 return SWIG_Python_InitShadowInstance(args);
27511 }
27512
27513 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27514 PyObject *resultobj = 0;
27515 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27516 int arg2 = (int) 0 ;
27517 wxMenu *arg3 = (wxMenu *) NULL ;
27518 wxMenuEvent *result = 0 ;
27519 int val1 ;
27520 int ecode1 = 0 ;
27521 int val2 ;
27522 int ecode2 = 0 ;
27523 void *argp3 = 0 ;
27524 int res3 = 0 ;
27525 PyObject * obj0 = 0 ;
27526 PyObject * obj1 = 0 ;
27527 PyObject * obj2 = 0 ;
27528 char * kwnames[] = {
27529 (char *) "type",(char *) "winid",(char *) "menu", NULL
27530 };
27531
27532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27533 if (obj0) {
27534 ecode1 = SWIG_AsVal_int(obj0, &val1);
27535 if (!SWIG_IsOK(ecode1)) {
27536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27537 }
27538 arg1 = static_cast< wxEventType >(val1);
27539 }
27540 if (obj1) {
27541 ecode2 = SWIG_AsVal_int(obj1, &val2);
27542 if (!SWIG_IsOK(ecode2)) {
27543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27544 }
27545 arg2 = static_cast< int >(val2);
27546 }
27547 if (obj2) {
27548 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27549 if (!SWIG_IsOK(res3)) {
27550 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27551 }
27552 arg3 = reinterpret_cast< wxMenu * >(argp3);
27553 }
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *resultobj = 0;
27569 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27570 int result;
27571 void *argp1 = 0 ;
27572 int res1 = 0 ;
27573 PyObject *swig_obj[1] ;
27574
27575 if (!args) SWIG_fail;
27576 swig_obj[0] = args;
27577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27578 if (!SWIG_IsOK(res1)) {
27579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27580 }
27581 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 resultobj = SWIG_From_int(static_cast< int >(result));
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27596 PyObject *resultobj = 0;
27597 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27598 bool result;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 PyObject *swig_obj[1] ;
27602
27603 if (!args) SWIG_fail;
27604 swig_obj[0] = args;
27605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27606 if (!SWIG_IsOK(res1)) {
27607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27608 }
27609 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 {
27617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27618 }
27619 return resultobj;
27620 fail:
27621 return NULL;
27622 }
27623
27624
27625 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27626 PyObject *resultobj = 0;
27627 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27628 wxMenu *result = 0 ;
27629 void *argp1 = 0 ;
27630 int res1 = 0 ;
27631 PyObject *swig_obj[1] ;
27632
27633 if (!args) SWIG_fail;
27634 swig_obj[0] = args;
27635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27636 if (!SWIG_IsOK(res1)) {
27637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27638 }
27639 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27643 wxPyEndAllowThreads(__tstate);
27644 if (PyErr_Occurred()) SWIG_fail;
27645 }
27646 {
27647 resultobj = wxPyMake_wxObject(result, (bool)0);
27648 }
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27656 PyObject *obj;
27657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27658 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27659 return SWIG_Py_Void();
27660 }
27661
27662 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 return SWIG_Python_InitShadowInstance(args);
27664 }
27665
27666 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27667 PyObject *resultobj = 0;
27668 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27669 int arg2 = (int) 0 ;
27670 wxCloseEvent *result = 0 ;
27671 int val1 ;
27672 int ecode1 = 0 ;
27673 int val2 ;
27674 int ecode2 = 0 ;
27675 PyObject * obj0 = 0 ;
27676 PyObject * obj1 = 0 ;
27677 char * kwnames[] = {
27678 (char *) "type",(char *) "winid", NULL
27679 };
27680
27681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27682 if (obj0) {
27683 ecode1 = SWIG_AsVal_int(obj0, &val1);
27684 if (!SWIG_IsOK(ecode1)) {
27685 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27686 }
27687 arg1 = static_cast< wxEventType >(val1);
27688 }
27689 if (obj1) {
27690 ecode2 = SWIG_AsVal_int(obj1, &val2);
27691 if (!SWIG_IsOK(ecode2)) {
27692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27693 }
27694 arg2 = static_cast< int >(val2);
27695 }
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27703 return resultobj;
27704 fail:
27705 return NULL;
27706 }
27707
27708
27709 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27710 PyObject *resultobj = 0;
27711 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27712 bool arg2 ;
27713 void *argp1 = 0 ;
27714 int res1 = 0 ;
27715 bool val2 ;
27716 int ecode2 = 0 ;
27717 PyObject * obj0 = 0 ;
27718 PyObject * obj1 = 0 ;
27719 char * kwnames[] = {
27720 (char *) "self",(char *) "logOff", NULL
27721 };
27722
27723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27725 if (!SWIG_IsOK(res1)) {
27726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27727 }
27728 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27729 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27730 if (!SWIG_IsOK(ecode2)) {
27731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27732 }
27733 arg2 = static_cast< bool >(val2);
27734 {
27735 PyThreadState* __tstate = wxPyBeginAllowThreads();
27736 (arg1)->SetLoggingOff(arg2);
27737 wxPyEndAllowThreads(__tstate);
27738 if (PyErr_Occurred()) SWIG_fail;
27739 }
27740 resultobj = SWIG_Py_Void();
27741 return resultobj;
27742 fail:
27743 return NULL;
27744 }
27745
27746
27747 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27748 PyObject *resultobj = 0;
27749 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27750 bool result;
27751 void *argp1 = 0 ;
27752 int res1 = 0 ;
27753 PyObject *swig_obj[1] ;
27754
27755 if (!args) SWIG_fail;
27756 swig_obj[0] = args;
27757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27758 if (!SWIG_IsOK(res1)) {
27759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27760 }
27761 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27762 {
27763 PyThreadState* __tstate = wxPyBeginAllowThreads();
27764 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 {
27769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27770 }
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27778 PyObject *resultobj = 0;
27779 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27780 bool arg2 = (bool) true ;
27781 void *argp1 = 0 ;
27782 int res1 = 0 ;
27783 bool val2 ;
27784 int ecode2 = 0 ;
27785 PyObject * obj0 = 0 ;
27786 PyObject * obj1 = 0 ;
27787 char * kwnames[] = {
27788 (char *) "self",(char *) "veto", NULL
27789 };
27790
27791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27793 if (!SWIG_IsOK(res1)) {
27794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27795 }
27796 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27797 if (obj1) {
27798 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27799 if (!SWIG_IsOK(ecode2)) {
27800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27801 }
27802 arg2 = static_cast< bool >(val2);
27803 }
27804 {
27805 PyThreadState* __tstate = wxPyBeginAllowThreads();
27806 (arg1)->Veto(arg2);
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 resultobj = SWIG_Py_Void();
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27818 PyObject *resultobj = 0;
27819 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27820 bool result;
27821 void *argp1 = 0 ;
27822 int res1 = 0 ;
27823 PyObject *swig_obj[1] ;
27824
27825 if (!args) SWIG_fail;
27826 swig_obj[0] = args;
27827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27828 if (!SWIG_IsOK(res1)) {
27829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27830 }
27831 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27835 wxPyEndAllowThreads(__tstate);
27836 if (PyErr_Occurred()) SWIG_fail;
27837 }
27838 {
27839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27840 }
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27848 PyObject *resultobj = 0;
27849 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27850 bool arg2 ;
27851 void *argp1 = 0 ;
27852 int res1 = 0 ;
27853 bool val2 ;
27854 int ecode2 = 0 ;
27855 PyObject * obj0 = 0 ;
27856 PyObject * obj1 = 0 ;
27857 char * kwnames[] = {
27858 (char *) "self",(char *) "canVeto", NULL
27859 };
27860
27861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27863 if (!SWIG_IsOK(res1)) {
27864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27865 }
27866 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27867 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27868 if (!SWIG_IsOK(ecode2)) {
27869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27870 }
27871 arg2 = static_cast< bool >(val2);
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 (arg1)->SetCanVeto(arg2);
27875 wxPyEndAllowThreads(__tstate);
27876 if (PyErr_Occurred()) SWIG_fail;
27877 }
27878 resultobj = SWIG_Py_Void();
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27886 PyObject *resultobj = 0;
27887 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27888 bool result;
27889 void *argp1 = 0 ;
27890 int res1 = 0 ;
27891 PyObject *swig_obj[1] ;
27892
27893 if (!args) SWIG_fail;
27894 swig_obj[0] = args;
27895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27896 if (!SWIG_IsOK(res1)) {
27897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27898 }
27899 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 {
27907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27908 }
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27916 PyObject *obj;
27917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27918 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27919 return SWIG_Py_Void();
27920 }
27921
27922 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27923 return SWIG_Python_InitShadowInstance(args);
27924 }
27925
27926 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27927 PyObject *resultobj = 0;
27928 int arg1 = (int) 0 ;
27929 bool arg2 = (bool) false ;
27930 wxShowEvent *result = 0 ;
27931 int val1 ;
27932 int ecode1 = 0 ;
27933 bool val2 ;
27934 int ecode2 = 0 ;
27935 PyObject * obj0 = 0 ;
27936 PyObject * obj1 = 0 ;
27937 char * kwnames[] = {
27938 (char *) "winid",(char *) "show", NULL
27939 };
27940
27941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27942 if (obj0) {
27943 ecode1 = SWIG_AsVal_int(obj0, &val1);
27944 if (!SWIG_IsOK(ecode1)) {
27945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27946 }
27947 arg1 = static_cast< int >(val1);
27948 }
27949 if (obj1) {
27950 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27951 if (!SWIG_IsOK(ecode2)) {
27952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27953 }
27954 arg2 = static_cast< bool >(val2);
27955 }
27956 {
27957 PyThreadState* __tstate = wxPyBeginAllowThreads();
27958 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27959 wxPyEndAllowThreads(__tstate);
27960 if (PyErr_Occurred()) SWIG_fail;
27961 }
27962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27963 return resultobj;
27964 fail:
27965 return NULL;
27966 }
27967
27968
27969 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27970 PyObject *resultobj = 0;
27971 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27972 bool arg2 ;
27973 void *argp1 = 0 ;
27974 int res1 = 0 ;
27975 bool val2 ;
27976 int ecode2 = 0 ;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 char * kwnames[] = {
27980 (char *) "self",(char *) "show", NULL
27981 };
27982
27983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27985 if (!SWIG_IsOK(res1)) {
27986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27987 }
27988 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27989 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27990 if (!SWIG_IsOK(ecode2)) {
27991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27992 }
27993 arg2 = static_cast< bool >(val2);
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 (arg1)->SetShow(arg2);
27997 wxPyEndAllowThreads(__tstate);
27998 if (PyErr_Occurred()) SWIG_fail;
27999 }
28000 resultobj = SWIG_Py_Void();
28001 return resultobj;
28002 fail:
28003 return NULL;
28004 }
28005
28006
28007 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28008 PyObject *resultobj = 0;
28009 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
28010 bool result;
28011 void *argp1 = 0 ;
28012 int res1 = 0 ;
28013 PyObject *swig_obj[1] ;
28014
28015 if (!args) SWIG_fail;
28016 swig_obj[0] = args;
28017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
28018 if (!SWIG_IsOK(res1)) {
28019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
28020 }
28021 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 result = (bool)((wxShowEvent const *)arg1)->GetShow();
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 {
28029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28030 }
28031 return resultobj;
28032 fail:
28033 return NULL;
28034 }
28035
28036
28037 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28038 PyObject *obj;
28039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28040 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
28041 return SWIG_Py_Void();
28042 }
28043
28044 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28045 return SWIG_Python_InitShadowInstance(args);
28046 }
28047
28048 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28049 PyObject *resultobj = 0;
28050 int arg1 = (int) 0 ;
28051 bool arg2 = (bool) true ;
28052 wxIconizeEvent *result = 0 ;
28053 int val1 ;
28054 int ecode1 = 0 ;
28055 bool val2 ;
28056 int ecode2 = 0 ;
28057 PyObject * obj0 = 0 ;
28058 PyObject * obj1 = 0 ;
28059 char * kwnames[] = {
28060 (char *) "id",(char *) "iconized", NULL
28061 };
28062
28063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28064 if (obj0) {
28065 ecode1 = SWIG_AsVal_int(obj0, &val1);
28066 if (!SWIG_IsOK(ecode1)) {
28067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
28068 }
28069 arg1 = static_cast< int >(val1);
28070 }
28071 if (obj1) {
28072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28073 if (!SWIG_IsOK(ecode2)) {
28074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
28075 }
28076 arg2 = static_cast< bool >(val2);
28077 }
28078 {
28079 PyThreadState* __tstate = wxPyBeginAllowThreads();
28080 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28092 PyObject *resultobj = 0;
28093 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
28094 bool result;
28095 void *argp1 = 0 ;
28096 int res1 = 0 ;
28097 PyObject *swig_obj[1] ;
28098
28099 if (!args) SWIG_fail;
28100 swig_obj[0] = args;
28101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
28102 if (!SWIG_IsOK(res1)) {
28103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
28104 }
28105 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 result = (bool)(arg1)->Iconized();
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 {
28113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28114 }
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28122 PyObject *obj;
28123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28124 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
28125 return SWIG_Py_Void();
28126 }
28127
28128 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28129 return SWIG_Python_InitShadowInstance(args);
28130 }
28131
28132 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 int arg1 = (int) 0 ;
28135 wxMaximizeEvent *result = 0 ;
28136 int val1 ;
28137 int ecode1 = 0 ;
28138 PyObject * obj0 = 0 ;
28139 char * kwnames[] = {
28140 (char *) "id", NULL
28141 };
28142
28143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
28144 if (obj0) {
28145 ecode1 = SWIG_AsVal_int(obj0, &val1);
28146 if (!SWIG_IsOK(ecode1)) {
28147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
28148 }
28149 arg1 = static_cast< int >(val1);
28150 }
28151 {
28152 PyThreadState* __tstate = wxPyBeginAllowThreads();
28153 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
28154 wxPyEndAllowThreads(__tstate);
28155 if (PyErr_Occurred()) SWIG_fail;
28156 }
28157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
28158 return resultobj;
28159 fail:
28160 return NULL;
28161 }
28162
28163
28164 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28165 PyObject *obj;
28166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28167 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
28168 return SWIG_Py_Void();
28169 }
28170
28171 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28172 return SWIG_Python_InitShadowInstance(args);
28173 }
28174
28175 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28176 PyObject *resultobj = 0;
28177 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28178 wxPoint result;
28179 void *argp1 = 0 ;
28180 int res1 = 0 ;
28181 PyObject *swig_obj[1] ;
28182
28183 if (!args) SWIG_fail;
28184 swig_obj[0] = args;
28185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28186 if (!SWIG_IsOK(res1)) {
28187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28188 }
28189 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 result = (arg1)->GetPosition();
28193 wxPyEndAllowThreads(__tstate);
28194 if (PyErr_Occurred()) SWIG_fail;
28195 }
28196 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
28197 return resultobj;
28198 fail:
28199 return NULL;
28200 }
28201
28202
28203 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28204 PyObject *resultobj = 0;
28205 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28206 int result;
28207 void *argp1 = 0 ;
28208 int res1 = 0 ;
28209 PyObject *swig_obj[1] ;
28210
28211 if (!args) SWIG_fail;
28212 swig_obj[0] = args;
28213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28214 if (!SWIG_IsOK(res1)) {
28215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28216 }
28217 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28218 {
28219 PyThreadState* __tstate = wxPyBeginAllowThreads();
28220 result = (int)(arg1)->GetNumberOfFiles();
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 resultobj = SWIG_From_int(static_cast< int >(result));
28225 return resultobj;
28226 fail:
28227 return NULL;
28228 }
28229
28230
28231 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28232 PyObject *resultobj = 0;
28233 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28234 PyObject *result = 0 ;
28235 void *argp1 = 0 ;
28236 int res1 = 0 ;
28237 PyObject *swig_obj[1] ;
28238
28239 if (!args) SWIG_fail;
28240 swig_obj[0] = args;
28241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28242 if (!SWIG_IsOK(res1)) {
28243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28244 }
28245 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28246 {
28247 PyThreadState* __tstate = wxPyBeginAllowThreads();
28248 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
28249 wxPyEndAllowThreads(__tstate);
28250 if (PyErr_Occurred()) SWIG_fail;
28251 }
28252 resultobj = result;
28253 return resultobj;
28254 fail:
28255 return NULL;
28256 }
28257
28258
28259 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28260 PyObject *obj;
28261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28262 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
28263 return SWIG_Py_Void();
28264 }
28265
28266 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28267 PyObject *resultobj = 0;
28268 int arg1 = (int) 0 ;
28269 wxUpdateUIEvent *result = 0 ;
28270 int val1 ;
28271 int ecode1 = 0 ;
28272 PyObject * obj0 = 0 ;
28273 char * kwnames[] = {
28274 (char *) "commandId", NULL
28275 };
28276
28277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
28278 if (obj0) {
28279 ecode1 = SWIG_AsVal_int(obj0, &val1);
28280 if (!SWIG_IsOK(ecode1)) {
28281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
28282 }
28283 arg1 = static_cast< int >(val1);
28284 }
28285 {
28286 PyThreadState* __tstate = wxPyBeginAllowThreads();
28287 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28299 PyObject *resultobj = 0;
28300 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28301 bool result;
28302 void *argp1 = 0 ;
28303 int res1 = 0 ;
28304 PyObject *swig_obj[1] ;
28305
28306 if (!args) SWIG_fail;
28307 swig_obj[0] = args;
28308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28309 if (!SWIG_IsOK(res1)) {
28310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28311 }
28312 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28313 {
28314 PyThreadState* __tstate = wxPyBeginAllowThreads();
28315 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 {
28320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28321 }
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28329 PyObject *resultobj = 0;
28330 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28331 bool result;
28332 void *argp1 = 0 ;
28333 int res1 = 0 ;
28334 PyObject *swig_obj[1] ;
28335
28336 if (!args) SWIG_fail;
28337 swig_obj[0] = args;
28338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28339 if (!SWIG_IsOK(res1)) {
28340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28341 }
28342 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28343 {
28344 PyThreadState* __tstate = wxPyBeginAllowThreads();
28345 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
28346 wxPyEndAllowThreads(__tstate);
28347 if (PyErr_Occurred()) SWIG_fail;
28348 }
28349 {
28350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28351 }
28352 return resultobj;
28353 fail:
28354 return NULL;
28355 }
28356
28357
28358 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28359 PyObject *resultobj = 0;
28360 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28361 bool result;
28362 void *argp1 = 0 ;
28363 int res1 = 0 ;
28364 PyObject *swig_obj[1] ;
28365
28366 if (!args) SWIG_fail;
28367 swig_obj[0] = args;
28368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28369 if (!SWIG_IsOK(res1)) {
28370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28371 }
28372 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 {
28380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28381 }
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28389 PyObject *resultobj = 0;
28390 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28391 wxString result;
28392 void *argp1 = 0 ;
28393 int res1 = 0 ;
28394 PyObject *swig_obj[1] ;
28395
28396 if (!args) SWIG_fail;
28397 swig_obj[0] = args;
28398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28399 if (!SWIG_IsOK(res1)) {
28400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28401 }
28402 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = ((wxUpdateUIEvent const *)arg1)->GetText();
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 {
28410 #if wxUSE_UNICODE
28411 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28412 #else
28413 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28414 #endif
28415 }
28416 return resultobj;
28417 fail:
28418 return NULL;
28419 }
28420
28421
28422 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28423 PyObject *resultobj = 0;
28424 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28425 bool result;
28426 void *argp1 = 0 ;
28427 int res1 = 0 ;
28428 PyObject *swig_obj[1] ;
28429
28430 if (!args) SWIG_fail;
28431 swig_obj[0] = args;
28432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28433 if (!SWIG_IsOK(res1)) {
28434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28435 }
28436 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28437 {
28438 PyThreadState* __tstate = wxPyBeginAllowThreads();
28439 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
28440 wxPyEndAllowThreads(__tstate);
28441 if (PyErr_Occurred()) SWIG_fail;
28442 }
28443 {
28444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28445 }
28446 return resultobj;
28447 fail:
28448 return NULL;
28449 }
28450
28451
28452 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28453 PyObject *resultobj = 0;
28454 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28455 bool result;
28456 void *argp1 = 0 ;
28457 int res1 = 0 ;
28458 PyObject *swig_obj[1] ;
28459
28460 if (!args) SWIG_fail;
28461 swig_obj[0] = args;
28462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28463 if (!SWIG_IsOK(res1)) {
28464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28465 }
28466 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28467 {
28468 PyThreadState* __tstate = wxPyBeginAllowThreads();
28469 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
28470 wxPyEndAllowThreads(__tstate);
28471 if (PyErr_Occurred()) SWIG_fail;
28472 }
28473 {
28474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28475 }
28476 return resultobj;
28477 fail:
28478 return NULL;
28479 }
28480
28481
28482 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28483 PyObject *resultobj = 0;
28484 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28485 bool result;
28486 void *argp1 = 0 ;
28487 int res1 = 0 ;
28488 PyObject *swig_obj[1] ;
28489
28490 if (!args) SWIG_fail;
28491 swig_obj[0] = args;
28492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28493 if (!SWIG_IsOK(res1)) {
28494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28495 }
28496 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
28500 wxPyEndAllowThreads(__tstate);
28501 if (PyErr_Occurred()) SWIG_fail;
28502 }
28503 {
28504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28505 }
28506 return resultobj;
28507 fail:
28508 return NULL;
28509 }
28510
28511
28512 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28513 PyObject *resultobj = 0;
28514 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28515 bool result;
28516 void *argp1 = 0 ;
28517 int res1 = 0 ;
28518 PyObject *swig_obj[1] ;
28519
28520 if (!args) SWIG_fail;
28521 swig_obj[0] = args;
28522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28523 if (!SWIG_IsOK(res1)) {
28524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28525 }
28526 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28527 {
28528 PyThreadState* __tstate = wxPyBeginAllowThreads();
28529 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 {
28534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28535 }
28536 return resultobj;
28537 fail:
28538 return NULL;
28539 }
28540
28541
28542 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28543 PyObject *resultobj = 0;
28544 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28545 bool arg2 ;
28546 void *argp1 = 0 ;
28547 int res1 = 0 ;
28548 bool val2 ;
28549 int ecode2 = 0 ;
28550 PyObject * obj0 = 0 ;
28551 PyObject * obj1 = 0 ;
28552 char * kwnames[] = {
28553 (char *) "self",(char *) "check", NULL
28554 };
28555
28556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28558 if (!SWIG_IsOK(res1)) {
28559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28560 }
28561 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28562 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28563 if (!SWIG_IsOK(ecode2)) {
28564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28565 }
28566 arg2 = static_cast< bool >(val2);
28567 {
28568 PyThreadState* __tstate = wxPyBeginAllowThreads();
28569 (arg1)->Check(arg2);
28570 wxPyEndAllowThreads(__tstate);
28571 if (PyErr_Occurred()) SWIG_fail;
28572 }
28573 resultobj = SWIG_Py_Void();
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28581 PyObject *resultobj = 0;
28582 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28583 bool arg2 ;
28584 void *argp1 = 0 ;
28585 int res1 = 0 ;
28586 bool val2 ;
28587 int ecode2 = 0 ;
28588 PyObject * obj0 = 0 ;
28589 PyObject * obj1 = 0 ;
28590 char * kwnames[] = {
28591 (char *) "self",(char *) "enable", NULL
28592 };
28593
28594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28598 }
28599 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28600 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28601 if (!SWIG_IsOK(ecode2)) {
28602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28603 }
28604 arg2 = static_cast< bool >(val2);
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 (arg1)->Enable(arg2);
28608 wxPyEndAllowThreads(__tstate);
28609 if (PyErr_Occurred()) SWIG_fail;
28610 }
28611 resultobj = SWIG_Py_Void();
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28619 PyObject *resultobj = 0;
28620 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28621 bool arg2 ;
28622 void *argp1 = 0 ;
28623 int res1 = 0 ;
28624 bool val2 ;
28625 int ecode2 = 0 ;
28626 PyObject * obj0 = 0 ;
28627 PyObject * obj1 = 0 ;
28628 char * kwnames[] = {
28629 (char *) "self",(char *) "show", NULL
28630 };
28631
28632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28634 if (!SWIG_IsOK(res1)) {
28635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28636 }
28637 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28639 if (!SWIG_IsOK(ecode2)) {
28640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28641 }
28642 arg2 = static_cast< bool >(val2);
28643 {
28644 PyThreadState* __tstate = wxPyBeginAllowThreads();
28645 (arg1)->Show(arg2);
28646 wxPyEndAllowThreads(__tstate);
28647 if (PyErr_Occurred()) SWIG_fail;
28648 }
28649 resultobj = SWIG_Py_Void();
28650 return resultobj;
28651 fail:
28652 return NULL;
28653 }
28654
28655
28656 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28657 PyObject *resultobj = 0;
28658 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28659 wxString *arg2 = 0 ;
28660 void *argp1 = 0 ;
28661 int res1 = 0 ;
28662 bool temp2 = false ;
28663 PyObject * obj0 = 0 ;
28664 PyObject * obj1 = 0 ;
28665 char * kwnames[] = {
28666 (char *) "self",(char *) "text", NULL
28667 };
28668
28669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28671 if (!SWIG_IsOK(res1)) {
28672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28673 }
28674 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28675 {
28676 arg2 = wxString_in_helper(obj1);
28677 if (arg2 == NULL) SWIG_fail;
28678 temp2 = true;
28679 }
28680 {
28681 PyThreadState* __tstate = wxPyBeginAllowThreads();
28682 (arg1)->SetText((wxString const &)*arg2);
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 resultobj = SWIG_Py_Void();
28687 {
28688 if (temp2)
28689 delete arg2;
28690 }
28691 return resultobj;
28692 fail:
28693 {
28694 if (temp2)
28695 delete arg2;
28696 }
28697 return NULL;
28698 }
28699
28700
28701 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28702 PyObject *resultobj = 0;
28703 long arg1 ;
28704 long val1 ;
28705 int ecode1 = 0 ;
28706 PyObject * obj0 = 0 ;
28707 char * kwnames[] = {
28708 (char *) "updateInterval", NULL
28709 };
28710
28711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28712 ecode1 = SWIG_AsVal_long(obj0, &val1);
28713 if (!SWIG_IsOK(ecode1)) {
28714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28715 }
28716 arg1 = static_cast< long >(val1);
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 wxUpdateUIEvent::SetUpdateInterval(arg1);
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 resultobj = SWIG_Py_Void();
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 PyObject *resultobj = 0;
28732 long result;
28733
28734 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 resultobj = SWIG_From_long(static_cast< long >(result));
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28749 PyObject *resultobj = 0;
28750 wxWindow *arg1 = (wxWindow *) 0 ;
28751 bool result;
28752 void *argp1 = 0 ;
28753 int res1 = 0 ;
28754 PyObject * obj0 = 0 ;
28755 char * kwnames[] = {
28756 (char *) "win", NULL
28757 };
28758
28759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28761 if (!SWIG_IsOK(res1)) {
28762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28763 }
28764 arg1 = reinterpret_cast< wxWindow * >(argp1);
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28768 wxPyEndAllowThreads(__tstate);
28769 if (PyErr_Occurred()) SWIG_fail;
28770 }
28771 {
28772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28773 }
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28781 PyObject *resultobj = 0;
28782
28783 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28784 {
28785 PyThreadState* __tstate = wxPyBeginAllowThreads();
28786 wxUpdateUIEvent::ResetUpdateTime();
28787 wxPyEndAllowThreads(__tstate);
28788 if (PyErr_Occurred()) SWIG_fail;
28789 }
28790 resultobj = SWIG_Py_Void();
28791 return resultobj;
28792 fail:
28793 return NULL;
28794 }
28795
28796
28797 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28798 PyObject *resultobj = 0;
28799 wxUpdateUIMode arg1 ;
28800 int val1 ;
28801 int ecode1 = 0 ;
28802 PyObject * obj0 = 0 ;
28803 char * kwnames[] = {
28804 (char *) "mode", NULL
28805 };
28806
28807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28808 ecode1 = SWIG_AsVal_int(obj0, &val1);
28809 if (!SWIG_IsOK(ecode1)) {
28810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28811 }
28812 arg1 = static_cast< wxUpdateUIMode >(val1);
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 wxUpdateUIEvent::SetMode(arg1);
28816 wxPyEndAllowThreads(__tstate);
28817 if (PyErr_Occurred()) SWIG_fail;
28818 }
28819 resultobj = SWIG_Py_Void();
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28827 PyObject *resultobj = 0;
28828 wxUpdateUIMode result;
28829
28830 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28831 {
28832 PyThreadState* __tstate = wxPyBeginAllowThreads();
28833 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28834 wxPyEndAllowThreads(__tstate);
28835 if (PyErr_Occurred()) SWIG_fail;
28836 }
28837 resultobj = SWIG_From_int(static_cast< int >(result));
28838 return resultobj;
28839 fail:
28840 return NULL;
28841 }
28842
28843
28844 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28845 PyObject *obj;
28846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28847 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28848 return SWIG_Py_Void();
28849 }
28850
28851 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28852 return SWIG_Python_InitShadowInstance(args);
28853 }
28854
28855 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28856 PyObject *resultobj = 0;
28857 wxSysColourChangedEvent *result = 0 ;
28858
28859 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28860 {
28861 PyThreadState* __tstate = wxPyBeginAllowThreads();
28862 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28863 wxPyEndAllowThreads(__tstate);
28864 if (PyErr_Occurred()) SWIG_fail;
28865 }
28866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28867 return resultobj;
28868 fail:
28869 return NULL;
28870 }
28871
28872
28873 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28874 PyObject *obj;
28875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28876 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28877 return SWIG_Py_Void();
28878 }
28879
28880 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28881 return SWIG_Python_InitShadowInstance(args);
28882 }
28883
28884 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28885 PyObject *resultobj = 0;
28886 int arg1 = (int) 0 ;
28887 wxWindow *arg2 = (wxWindow *) NULL ;
28888 wxMouseCaptureChangedEvent *result = 0 ;
28889 int val1 ;
28890 int ecode1 = 0 ;
28891 void *argp2 = 0 ;
28892 int res2 = 0 ;
28893 PyObject * obj0 = 0 ;
28894 PyObject * obj1 = 0 ;
28895 char * kwnames[] = {
28896 (char *) "winid",(char *) "gainedCapture", NULL
28897 };
28898
28899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28900 if (obj0) {
28901 ecode1 = SWIG_AsVal_int(obj0, &val1);
28902 if (!SWIG_IsOK(ecode1)) {
28903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28904 }
28905 arg1 = static_cast< int >(val1);
28906 }
28907 if (obj1) {
28908 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28909 if (!SWIG_IsOK(res2)) {
28910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28911 }
28912 arg2 = reinterpret_cast< wxWindow * >(argp2);
28913 }
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28928 PyObject *resultobj = 0;
28929 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28930 wxWindow *result = 0 ;
28931 void *argp1 = 0 ;
28932 int res1 = 0 ;
28933 PyObject *swig_obj[1] ;
28934
28935 if (!args) SWIG_fail;
28936 swig_obj[0] = args;
28937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28938 if (!SWIG_IsOK(res1)) {
28939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28940 }
28941 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28942 {
28943 PyThreadState* __tstate = wxPyBeginAllowThreads();
28944 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 {
28949 resultobj = wxPyMake_wxObject(result, (bool)0);
28950 }
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28958 PyObject *obj;
28959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28960 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28961 return SWIG_Py_Void();
28962 }
28963
28964 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28965 return SWIG_Python_InitShadowInstance(args);
28966 }
28967
28968 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28969 PyObject *resultobj = 0;
28970 int arg1 = (int) 0 ;
28971 wxMouseCaptureLostEvent *result = 0 ;
28972 int val1 ;
28973 int ecode1 = 0 ;
28974 PyObject * obj0 = 0 ;
28975 char * kwnames[] = {
28976 (char *) "winid", NULL
28977 };
28978
28979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28980 if (obj0) {
28981 ecode1 = SWIG_AsVal_int(obj0, &val1);
28982 if (!SWIG_IsOK(ecode1)) {
28983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28984 }
28985 arg1 = static_cast< int >(val1);
28986 }
28987 {
28988 PyThreadState* __tstate = wxPyBeginAllowThreads();
28989 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29001 PyObject *obj;
29002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29003 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
29004 return SWIG_Py_Void();
29005 }
29006
29007 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29008 return SWIG_Python_InitShadowInstance(args);
29009 }
29010
29011 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29012 PyObject *resultobj = 0;
29013 wxDisplayChangedEvent *result = 0 ;
29014
29015 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
29023 return resultobj;
29024 fail:
29025 return NULL;
29026 }
29027
29028
29029 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29030 PyObject *obj;
29031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29032 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
29033 return SWIG_Py_Void();
29034 }
29035
29036 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29037 return SWIG_Python_InitShadowInstance(args);
29038 }
29039
29040 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29041 PyObject *resultobj = 0;
29042 int arg1 = (int) 0 ;
29043 wxPaletteChangedEvent *result = 0 ;
29044 int val1 ;
29045 int ecode1 = 0 ;
29046 PyObject * obj0 = 0 ;
29047 char * kwnames[] = {
29048 (char *) "id", NULL
29049 };
29050
29051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
29052 if (obj0) {
29053 ecode1 = SWIG_AsVal_int(obj0, &val1);
29054 if (!SWIG_IsOK(ecode1)) {
29055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
29056 }
29057 arg1 = static_cast< int >(val1);
29058 }
29059 {
29060 PyThreadState* __tstate = wxPyBeginAllowThreads();
29061 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
29062 wxPyEndAllowThreads(__tstate);
29063 if (PyErr_Occurred()) SWIG_fail;
29064 }
29065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
29066 return resultobj;
29067 fail:
29068 return NULL;
29069 }
29070
29071
29072 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29073 PyObject *resultobj = 0;
29074 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29075 wxWindow *arg2 = (wxWindow *) 0 ;
29076 void *argp1 = 0 ;
29077 int res1 = 0 ;
29078 void *argp2 = 0 ;
29079 int res2 = 0 ;
29080 PyObject * obj0 = 0 ;
29081 PyObject * obj1 = 0 ;
29082 char * kwnames[] = {
29083 (char *) "self",(char *) "win", NULL
29084 };
29085
29086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
29087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29088 if (!SWIG_IsOK(res1)) {
29089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29090 }
29091 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29092 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29093 if (!SWIG_IsOK(res2)) {
29094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
29095 }
29096 arg2 = reinterpret_cast< wxWindow * >(argp2);
29097 {
29098 PyThreadState* __tstate = wxPyBeginAllowThreads();
29099 (arg1)->SetChangedWindow(arg2);
29100 wxPyEndAllowThreads(__tstate);
29101 if (PyErr_Occurred()) SWIG_fail;
29102 }
29103 resultobj = SWIG_Py_Void();
29104 return resultobj;
29105 fail:
29106 return NULL;
29107 }
29108
29109
29110 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29111 PyObject *resultobj = 0;
29112 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29113 wxWindow *result = 0 ;
29114 void *argp1 = 0 ;
29115 int res1 = 0 ;
29116 PyObject *swig_obj[1] ;
29117
29118 if (!args) SWIG_fail;
29119 swig_obj[0] = args;
29120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29121 if (!SWIG_IsOK(res1)) {
29122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29123 }
29124 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29125 {
29126 PyThreadState* __tstate = wxPyBeginAllowThreads();
29127 result = (wxWindow *)(arg1)->GetChangedWindow();
29128 wxPyEndAllowThreads(__tstate);
29129 if (PyErr_Occurred()) SWIG_fail;
29130 }
29131 {
29132 resultobj = wxPyMake_wxObject(result, (bool)0);
29133 }
29134 return resultobj;
29135 fail:
29136 return NULL;
29137 }
29138
29139
29140 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29141 PyObject *obj;
29142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29143 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
29144 return SWIG_Py_Void();
29145 }
29146
29147 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29148 return SWIG_Python_InitShadowInstance(args);
29149 }
29150
29151 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29152 PyObject *resultobj = 0;
29153 int arg1 = (int) 0 ;
29154 wxQueryNewPaletteEvent *result = 0 ;
29155 int val1 ;
29156 int ecode1 = 0 ;
29157 PyObject * obj0 = 0 ;
29158 char * kwnames[] = {
29159 (char *) "winid", NULL
29160 };
29161
29162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
29163 if (obj0) {
29164 ecode1 = SWIG_AsVal_int(obj0, &val1);
29165 if (!SWIG_IsOK(ecode1)) {
29166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
29167 }
29168 arg1 = static_cast< int >(val1);
29169 }
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
29173 wxPyEndAllowThreads(__tstate);
29174 if (PyErr_Occurred()) SWIG_fail;
29175 }
29176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
29177 return resultobj;
29178 fail:
29179 return NULL;
29180 }
29181
29182
29183 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29184 PyObject *resultobj = 0;
29185 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29186 bool arg2 ;
29187 void *argp1 = 0 ;
29188 int res1 = 0 ;
29189 bool val2 ;
29190 int ecode2 = 0 ;
29191 PyObject * obj0 = 0 ;
29192 PyObject * obj1 = 0 ;
29193 char * kwnames[] = {
29194 (char *) "self",(char *) "realized", NULL
29195 };
29196
29197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
29198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29199 if (!SWIG_IsOK(res1)) {
29200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
29201 }
29202 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29203 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29204 if (!SWIG_IsOK(ecode2)) {
29205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
29206 }
29207 arg2 = static_cast< bool >(val2);
29208 {
29209 PyThreadState* __tstate = wxPyBeginAllowThreads();
29210 (arg1)->SetPaletteRealized(arg2);
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 resultobj = SWIG_Py_Void();
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29222 PyObject *resultobj = 0;
29223 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29224 bool result;
29225 void *argp1 = 0 ;
29226 int res1 = 0 ;
29227 PyObject *swig_obj[1] ;
29228
29229 if (!args) SWIG_fail;
29230 swig_obj[0] = args;
29231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29232 if (!SWIG_IsOK(res1)) {
29233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
29234 }
29235 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29236 {
29237 PyThreadState* __tstate = wxPyBeginAllowThreads();
29238 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
29239 wxPyEndAllowThreads(__tstate);
29240 if (PyErr_Occurred()) SWIG_fail;
29241 }
29242 {
29243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29244 }
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29252 PyObject *obj;
29253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29254 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
29255 return SWIG_Py_Void();
29256 }
29257
29258 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29259 return SWIG_Python_InitShadowInstance(args);
29260 }
29261
29262 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29263 PyObject *resultobj = 0;
29264 wxNavigationKeyEvent *result = 0 ;
29265
29266 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
29267 {
29268 PyThreadState* __tstate = wxPyBeginAllowThreads();
29269 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
29270 wxPyEndAllowThreads(__tstate);
29271 if (PyErr_Occurred()) SWIG_fail;
29272 }
29273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
29274 return resultobj;
29275 fail:
29276 return NULL;
29277 }
29278
29279
29280 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29281 PyObject *resultobj = 0;
29282 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29283 bool result;
29284 void *argp1 = 0 ;
29285 int res1 = 0 ;
29286 PyObject *swig_obj[1] ;
29287
29288 if (!args) SWIG_fail;
29289 swig_obj[0] = args;
29290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29291 if (!SWIG_IsOK(res1)) {
29292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29293 }
29294 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29295 {
29296 PyThreadState* __tstate = wxPyBeginAllowThreads();
29297 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
29298 wxPyEndAllowThreads(__tstate);
29299 if (PyErr_Occurred()) SWIG_fail;
29300 }
29301 {
29302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29303 }
29304 return resultobj;
29305 fail:
29306 return NULL;
29307 }
29308
29309
29310 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29311 PyObject *resultobj = 0;
29312 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29313 bool arg2 ;
29314 void *argp1 = 0 ;
29315 int res1 = 0 ;
29316 bool val2 ;
29317 int ecode2 = 0 ;
29318 PyObject * obj0 = 0 ;
29319 PyObject * obj1 = 0 ;
29320 char * kwnames[] = {
29321 (char *) "self",(char *) "forward", NULL
29322 };
29323
29324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
29325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29326 if (!SWIG_IsOK(res1)) {
29327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29328 }
29329 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29331 if (!SWIG_IsOK(ecode2)) {
29332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
29333 }
29334 arg2 = static_cast< bool >(val2);
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 (arg1)->SetDirection(arg2);
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 resultobj = SWIG_Py_Void();
29342 return resultobj;
29343 fail:
29344 return NULL;
29345 }
29346
29347
29348 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29349 PyObject *resultobj = 0;
29350 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29351 bool result;
29352 void *argp1 = 0 ;
29353 int res1 = 0 ;
29354 PyObject *swig_obj[1] ;
29355
29356 if (!args) SWIG_fail;
29357 swig_obj[0] = args;
29358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29359 if (!SWIG_IsOK(res1)) {
29360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29361 }
29362 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29363 {
29364 PyThreadState* __tstate = wxPyBeginAllowThreads();
29365 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 {
29370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29371 }
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj = 0;
29380 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29381 bool arg2 ;
29382 void *argp1 = 0 ;
29383 int res1 = 0 ;
29384 bool val2 ;
29385 int ecode2 = 0 ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 char * kwnames[] = {
29389 (char *) "self",(char *) "ischange", NULL
29390 };
29391
29392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
29393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29396 }
29397 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29398 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29399 if (!SWIG_IsOK(ecode2)) {
29400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
29401 }
29402 arg2 = static_cast< bool >(val2);
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 (arg1)->SetWindowChange(arg2);
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 resultobj = SWIG_Py_Void();
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 PyObject *resultobj = 0;
29418 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29419 bool result;
29420 void *argp1 = 0 ;
29421 int res1 = 0 ;
29422 PyObject *swig_obj[1] ;
29423
29424 if (!args) SWIG_fail;
29425 swig_obj[0] = args;
29426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29427 if (!SWIG_IsOK(res1)) {
29428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29429 }
29430 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 {
29438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29439 }
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = 0;
29448 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29449 bool arg2 ;
29450 void *argp1 = 0 ;
29451 int res1 = 0 ;
29452 bool val2 ;
29453 int ecode2 = 0 ;
29454 PyObject * obj0 = 0 ;
29455 PyObject * obj1 = 0 ;
29456 char * kwnames[] = {
29457 (char *) "self",(char *) "bIs", NULL
29458 };
29459
29460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
29461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29462 if (!SWIG_IsOK(res1)) {
29463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29464 }
29465 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29466 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29467 if (!SWIG_IsOK(ecode2)) {
29468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
29469 }
29470 arg2 = static_cast< bool >(val2);
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 (arg1)->SetFromTab(arg2);
29474 wxPyEndAllowThreads(__tstate);
29475 if (PyErr_Occurred()) SWIG_fail;
29476 }
29477 resultobj = SWIG_Py_Void();
29478 return resultobj;
29479 fail:
29480 return NULL;
29481 }
29482
29483
29484 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29485 PyObject *resultobj = 0;
29486 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29487 long arg2 ;
29488 void *argp1 = 0 ;
29489 int res1 = 0 ;
29490 long val2 ;
29491 int ecode2 = 0 ;
29492 PyObject * obj0 = 0 ;
29493 PyObject * obj1 = 0 ;
29494 char * kwnames[] = {
29495 (char *) "self",(char *) "flags", NULL
29496 };
29497
29498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
29499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29500 if (!SWIG_IsOK(res1)) {
29501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29502 }
29503 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29504 ecode2 = SWIG_AsVal_long(obj1, &val2);
29505 if (!SWIG_IsOK(ecode2)) {
29506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
29507 }
29508 arg2 = static_cast< long >(val2);
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 (arg1)->SetFlags(arg2);
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 resultobj = SWIG_Py_Void();
29516 return resultobj;
29517 fail:
29518 return NULL;
29519 }
29520
29521
29522 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29523 PyObject *resultobj = 0;
29524 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29525 wxWindow *result = 0 ;
29526 void *argp1 = 0 ;
29527 int res1 = 0 ;
29528 PyObject *swig_obj[1] ;
29529
29530 if (!args) SWIG_fail;
29531 swig_obj[0] = args;
29532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29533 if (!SWIG_IsOK(res1)) {
29534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29535 }
29536 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29537 {
29538 PyThreadState* __tstate = wxPyBeginAllowThreads();
29539 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29540 wxPyEndAllowThreads(__tstate);
29541 if (PyErr_Occurred()) SWIG_fail;
29542 }
29543 {
29544 resultobj = wxPyMake_wxObject(result, (bool)0);
29545 }
29546 return resultobj;
29547 fail:
29548 return NULL;
29549 }
29550
29551
29552 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29553 PyObject *resultobj = 0;
29554 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29555 wxWindow *arg2 = (wxWindow *) 0 ;
29556 void *argp1 = 0 ;
29557 int res1 = 0 ;
29558 void *argp2 = 0 ;
29559 int res2 = 0 ;
29560 PyObject * obj0 = 0 ;
29561 PyObject * obj1 = 0 ;
29562 char * kwnames[] = {
29563 (char *) "self",(char *) "win", NULL
29564 };
29565
29566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29568 if (!SWIG_IsOK(res1)) {
29569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29570 }
29571 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29573 if (!SWIG_IsOK(res2)) {
29574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29575 }
29576 arg2 = reinterpret_cast< wxWindow * >(argp2);
29577 {
29578 PyThreadState* __tstate = wxPyBeginAllowThreads();
29579 (arg1)->SetCurrentFocus(arg2);
29580 wxPyEndAllowThreads(__tstate);
29581 if (PyErr_Occurred()) SWIG_fail;
29582 }
29583 resultobj = SWIG_Py_Void();
29584 return resultobj;
29585 fail:
29586 return NULL;
29587 }
29588
29589
29590 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29591 PyObject *obj;
29592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29593 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29594 return SWIG_Py_Void();
29595 }
29596
29597 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29598 return SWIG_Python_InitShadowInstance(args);
29599 }
29600
29601 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29602 PyObject *resultobj = 0;
29603 wxWindow *arg1 = (wxWindow *) NULL ;
29604 wxWindowCreateEvent *result = 0 ;
29605 void *argp1 = 0 ;
29606 int res1 = 0 ;
29607 PyObject * obj0 = 0 ;
29608 char * kwnames[] = {
29609 (char *) "win", NULL
29610 };
29611
29612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29613 if (obj0) {
29614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29615 if (!SWIG_IsOK(res1)) {
29616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29617 }
29618 arg1 = reinterpret_cast< wxWindow * >(argp1);
29619 }
29620 {
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29627 return resultobj;
29628 fail:
29629 return NULL;
29630 }
29631
29632
29633 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29634 PyObject *resultobj = 0;
29635 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29636 wxWindow *result = 0 ;
29637 void *argp1 = 0 ;
29638 int res1 = 0 ;
29639 PyObject *swig_obj[1] ;
29640
29641 if (!args) SWIG_fail;
29642 swig_obj[0] = args;
29643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29644 if (!SWIG_IsOK(res1)) {
29645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29646 }
29647 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29648 {
29649 PyThreadState* __tstate = wxPyBeginAllowThreads();
29650 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29651 wxPyEndAllowThreads(__tstate);
29652 if (PyErr_Occurred()) SWIG_fail;
29653 }
29654 {
29655 resultobj = wxPyMake_wxObject(result, (bool)0);
29656 }
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29664 PyObject *obj;
29665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29666 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29667 return SWIG_Py_Void();
29668 }
29669
29670 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29671 return SWIG_Python_InitShadowInstance(args);
29672 }
29673
29674 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29675 PyObject *resultobj = 0;
29676 wxWindow *arg1 = (wxWindow *) NULL ;
29677 wxWindowDestroyEvent *result = 0 ;
29678 void *argp1 = 0 ;
29679 int res1 = 0 ;
29680 PyObject * obj0 = 0 ;
29681 char * kwnames[] = {
29682 (char *) "win", NULL
29683 };
29684
29685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29686 if (obj0) {
29687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29688 if (!SWIG_IsOK(res1)) {
29689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29690 }
29691 arg1 = reinterpret_cast< wxWindow * >(argp1);
29692 }
29693 {
29694 PyThreadState* __tstate = wxPyBeginAllowThreads();
29695 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29696 wxPyEndAllowThreads(__tstate);
29697 if (PyErr_Occurred()) SWIG_fail;
29698 }
29699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29700 return resultobj;
29701 fail:
29702 return NULL;
29703 }
29704
29705
29706 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29707 PyObject *resultobj = 0;
29708 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29709 wxWindow *result = 0 ;
29710 void *argp1 = 0 ;
29711 int res1 = 0 ;
29712 PyObject *swig_obj[1] ;
29713
29714 if (!args) SWIG_fail;
29715 swig_obj[0] = args;
29716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29717 if (!SWIG_IsOK(res1)) {
29718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29719 }
29720 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29721 {
29722 PyThreadState* __tstate = wxPyBeginAllowThreads();
29723 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29724 wxPyEndAllowThreads(__tstate);
29725 if (PyErr_Occurred()) SWIG_fail;
29726 }
29727 {
29728 resultobj = wxPyMake_wxObject(result, (bool)0);
29729 }
29730 return resultobj;
29731 fail:
29732 return NULL;
29733 }
29734
29735
29736 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29737 PyObject *obj;
29738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29739 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29740 return SWIG_Py_Void();
29741 }
29742
29743 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29744 return SWIG_Python_InitShadowInstance(args);
29745 }
29746
29747 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29748 PyObject *resultobj = 0;
29749 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29750 int arg2 = (int) 0 ;
29751 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29752 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29753 wxContextMenuEvent *result = 0 ;
29754 int val1 ;
29755 int ecode1 = 0 ;
29756 int val2 ;
29757 int ecode2 = 0 ;
29758 wxPoint temp3 ;
29759 PyObject * obj0 = 0 ;
29760 PyObject * obj1 = 0 ;
29761 PyObject * obj2 = 0 ;
29762 char * kwnames[] = {
29763 (char *) "type",(char *) "winid",(char *) "pt", NULL
29764 };
29765
29766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29767 if (obj0) {
29768 ecode1 = SWIG_AsVal_int(obj0, &val1);
29769 if (!SWIG_IsOK(ecode1)) {
29770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29771 }
29772 arg1 = static_cast< wxEventType >(val1);
29773 }
29774 if (obj1) {
29775 ecode2 = SWIG_AsVal_int(obj1, &val2);
29776 if (!SWIG_IsOK(ecode2)) {
29777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29778 }
29779 arg2 = static_cast< int >(val2);
29780 }
29781 if (obj2) {
29782 {
29783 arg3 = &temp3;
29784 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29785 }
29786 }
29787 {
29788 PyThreadState* __tstate = wxPyBeginAllowThreads();
29789 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29790 wxPyEndAllowThreads(__tstate);
29791 if (PyErr_Occurred()) SWIG_fail;
29792 }
29793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29794 return resultobj;
29795 fail:
29796 return NULL;
29797 }
29798
29799
29800 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29801 PyObject *resultobj = 0;
29802 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29803 wxPoint *result = 0 ;
29804 void *argp1 = 0 ;
29805 int res1 = 0 ;
29806 PyObject *swig_obj[1] ;
29807
29808 if (!args) SWIG_fail;
29809 swig_obj[0] = args;
29810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29811 if (!SWIG_IsOK(res1)) {
29812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29813 }
29814 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29815 {
29816 PyThreadState* __tstate = wxPyBeginAllowThreads();
29817 {
29818 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29819 result = (wxPoint *) &_result_ref;
29820 }
29821 wxPyEndAllowThreads(__tstate);
29822 if (PyErr_Occurred()) SWIG_fail;
29823 }
29824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29825 return resultobj;
29826 fail:
29827 return NULL;
29828 }
29829
29830
29831 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29832 PyObject *resultobj = 0;
29833 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29834 wxPoint *arg2 = 0 ;
29835 void *argp1 = 0 ;
29836 int res1 = 0 ;
29837 wxPoint temp2 ;
29838 PyObject * obj0 = 0 ;
29839 PyObject * obj1 = 0 ;
29840 char * kwnames[] = {
29841 (char *) "self",(char *) "pos", NULL
29842 };
29843
29844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29846 if (!SWIG_IsOK(res1)) {
29847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29848 }
29849 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29850 {
29851 arg2 = &temp2;
29852 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29853 }
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 (arg1)->SetPosition((wxPoint const &)*arg2);
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 resultobj = SWIG_Py_Void();
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29868 PyObject *obj;
29869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29870 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29871 return SWIG_Py_Void();
29872 }
29873
29874 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29875 return SWIG_Python_InitShadowInstance(args);
29876 }
29877
29878 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29879 PyObject *resultobj = 0;
29880 wxIdleEvent *result = 0 ;
29881
29882 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29883 {
29884 PyThreadState* __tstate = wxPyBeginAllowThreads();
29885 result = (wxIdleEvent *)new wxIdleEvent();
29886 wxPyEndAllowThreads(__tstate);
29887 if (PyErr_Occurred()) SWIG_fail;
29888 }
29889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29890 return resultobj;
29891 fail:
29892 return NULL;
29893 }
29894
29895
29896 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29897 PyObject *resultobj = 0;
29898 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29899 bool arg2 = (bool) true ;
29900 void *argp1 = 0 ;
29901 int res1 = 0 ;
29902 bool val2 ;
29903 int ecode2 = 0 ;
29904 PyObject * obj0 = 0 ;
29905 PyObject * obj1 = 0 ;
29906 char * kwnames[] = {
29907 (char *) "self",(char *) "needMore", NULL
29908 };
29909
29910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29912 if (!SWIG_IsOK(res1)) {
29913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29914 }
29915 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29916 if (obj1) {
29917 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29918 if (!SWIG_IsOK(ecode2)) {
29919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29920 }
29921 arg2 = static_cast< bool >(val2);
29922 }
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 (arg1)->RequestMore(arg2);
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 resultobj = SWIG_Py_Void();
29930 return resultobj;
29931 fail:
29932 return NULL;
29933 }
29934
29935
29936 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29937 PyObject *resultobj = 0;
29938 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29939 bool result;
29940 void *argp1 = 0 ;
29941 int res1 = 0 ;
29942 PyObject *swig_obj[1] ;
29943
29944 if (!args) SWIG_fail;
29945 swig_obj[0] = args;
29946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29947 if (!SWIG_IsOK(res1)) {
29948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29949 }
29950 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29951 {
29952 PyThreadState* __tstate = wxPyBeginAllowThreads();
29953 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29954 wxPyEndAllowThreads(__tstate);
29955 if (PyErr_Occurred()) SWIG_fail;
29956 }
29957 {
29958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29959 }
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj = 0;
29968 wxIdleMode arg1 ;
29969 int val1 ;
29970 int ecode1 = 0 ;
29971 PyObject * obj0 = 0 ;
29972 char * kwnames[] = {
29973 (char *) "mode", NULL
29974 };
29975
29976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29977 ecode1 = SWIG_AsVal_int(obj0, &val1);
29978 if (!SWIG_IsOK(ecode1)) {
29979 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29980 }
29981 arg1 = static_cast< wxIdleMode >(val1);
29982 {
29983 PyThreadState* __tstate = wxPyBeginAllowThreads();
29984 wxIdleEvent::SetMode(arg1);
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 resultobj = SWIG_Py_Void();
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29996 PyObject *resultobj = 0;
29997 wxIdleMode result;
29998
29999 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 result = (wxIdleMode)wxIdleEvent::GetMode();
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 resultobj = SWIG_From_int(static_cast< int >(result));
30007 return resultobj;
30008 fail:
30009 return NULL;
30010 }
30011
30012
30013 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30014 PyObject *resultobj = 0;
30015 wxWindow *arg1 = (wxWindow *) 0 ;
30016 bool result;
30017 void *argp1 = 0 ;
30018 int res1 = 0 ;
30019 PyObject * obj0 = 0 ;
30020 char * kwnames[] = {
30021 (char *) "win", NULL
30022 };
30023
30024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
30025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30026 if (!SWIG_IsOK(res1)) {
30027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
30028 }
30029 arg1 = reinterpret_cast< wxWindow * >(argp1);
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 result = (bool)wxIdleEvent::CanSend(arg1);
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 {
30037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30038 }
30039 return resultobj;
30040 fail:
30041 return NULL;
30042 }
30043
30044
30045 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30046 PyObject *obj;
30047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30048 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
30049 return SWIG_Py_Void();
30050 }
30051
30052 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30053 return SWIG_Python_InitShadowInstance(args);
30054 }
30055
30056 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30057 PyObject *resultobj = 0;
30058 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30059 int arg2 = (int) 0 ;
30060 wxClipboardTextEvent *result = 0 ;
30061 int val1 ;
30062 int ecode1 = 0 ;
30063 int val2 ;
30064 int ecode2 = 0 ;
30065 PyObject * obj0 = 0 ;
30066 PyObject * obj1 = 0 ;
30067 char * kwnames[] = {
30068 (char *) "type",(char *) "winid", NULL
30069 };
30070
30071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30072 if (obj0) {
30073 ecode1 = SWIG_AsVal_int(obj0, &val1);
30074 if (!SWIG_IsOK(ecode1)) {
30075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30076 }
30077 arg1 = static_cast< wxEventType >(val1);
30078 }
30079 if (obj1) {
30080 ecode2 = SWIG_AsVal_int(obj1, &val2);
30081 if (!SWIG_IsOK(ecode2)) {
30082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
30083 }
30084 arg2 = static_cast< int >(val2);
30085 }
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *obj;
30101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30102 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
30103 return SWIG_Py_Void();
30104 }
30105
30106 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30107 return SWIG_Python_InitShadowInstance(args);
30108 }
30109
30110 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30111 PyObject *resultobj = 0;
30112 int arg1 = (int) 0 ;
30113 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
30114 wxPyEvent *result = 0 ;
30115 int val1 ;
30116 int ecode1 = 0 ;
30117 int val2 ;
30118 int ecode2 = 0 ;
30119 PyObject * obj0 = 0 ;
30120 PyObject * obj1 = 0 ;
30121 char * kwnames[] = {
30122 (char *) "winid",(char *) "eventType", NULL
30123 };
30124
30125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30126 if (obj0) {
30127 ecode1 = SWIG_AsVal_int(obj0, &val1);
30128 if (!SWIG_IsOK(ecode1)) {
30129 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
30130 }
30131 arg1 = static_cast< int >(val1);
30132 }
30133 if (obj1) {
30134 ecode2 = SWIG_AsVal_int(obj1, &val2);
30135 if (!SWIG_IsOK(ecode2)) {
30136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
30137 }
30138 arg2 = static_cast< wxEventType >(val2);
30139 }
30140 {
30141 PyThreadState* __tstate = wxPyBeginAllowThreads();
30142 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
30143 wxPyEndAllowThreads(__tstate);
30144 if (PyErr_Occurred()) SWIG_fail;
30145 }
30146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
30147 return resultobj;
30148 fail:
30149 return NULL;
30150 }
30151
30152
30153 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30154 PyObject *resultobj = 0;
30155 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30156 void *argp1 = 0 ;
30157 int res1 = 0 ;
30158 PyObject *swig_obj[1] ;
30159
30160 if (!args) SWIG_fail;
30161 swig_obj[0] = args;
30162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
30163 if (!SWIG_IsOK(res1)) {
30164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30165 }
30166 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30167 {
30168 PyThreadState* __tstate = wxPyBeginAllowThreads();
30169 delete arg1;
30170
30171 wxPyEndAllowThreads(__tstate);
30172 if (PyErr_Occurred()) SWIG_fail;
30173 }
30174 resultobj = SWIG_Py_Void();
30175 return resultobj;
30176 fail:
30177 return NULL;
30178 }
30179
30180
30181 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30182 PyObject *resultobj = 0;
30183 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30184 PyObject *arg2 = (PyObject *) 0 ;
30185 void *argp1 = 0 ;
30186 int res1 = 0 ;
30187 PyObject * obj0 = 0 ;
30188 PyObject * obj1 = 0 ;
30189 char * kwnames[] = {
30190 (char *) "self",(char *) "self", NULL
30191 };
30192
30193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30195 if (!SWIG_IsOK(res1)) {
30196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30197 }
30198 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30199 arg2 = obj1;
30200 {
30201 PyThreadState* __tstate = wxPyBeginAllowThreads();
30202 (arg1)->SetSelf(arg2);
30203 wxPyEndAllowThreads(__tstate);
30204 if (PyErr_Occurred()) SWIG_fail;
30205 }
30206 resultobj = SWIG_Py_Void();
30207 return resultobj;
30208 fail:
30209 return NULL;
30210 }
30211
30212
30213 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30214 PyObject *resultobj = 0;
30215 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30216 PyObject *result = 0 ;
30217 void *argp1 = 0 ;
30218 int res1 = 0 ;
30219 PyObject *swig_obj[1] ;
30220
30221 if (!args) SWIG_fail;
30222 swig_obj[0] = args;
30223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30224 if (!SWIG_IsOK(res1)) {
30225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30226 }
30227 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30228 {
30229 PyThreadState* __tstate = wxPyBeginAllowThreads();
30230 result = (PyObject *)(arg1)->GetSelf();
30231 wxPyEndAllowThreads(__tstate);
30232 if (PyErr_Occurred()) SWIG_fail;
30233 }
30234 resultobj = result;
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30242 PyObject *obj;
30243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30244 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
30245 return SWIG_Py_Void();
30246 }
30247
30248 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30249 return SWIG_Python_InitShadowInstance(args);
30250 }
30251
30252 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30253 PyObject *resultobj = 0;
30254 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30255 int arg2 = (int) 0 ;
30256 wxPyCommandEvent *result = 0 ;
30257 int val1 ;
30258 int ecode1 = 0 ;
30259 int val2 ;
30260 int ecode2 = 0 ;
30261 PyObject * obj0 = 0 ;
30262 PyObject * obj1 = 0 ;
30263 char * kwnames[] = {
30264 (char *) "eventType",(char *) "id", NULL
30265 };
30266
30267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30268 if (obj0) {
30269 ecode1 = SWIG_AsVal_int(obj0, &val1);
30270 if (!SWIG_IsOK(ecode1)) {
30271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30272 }
30273 arg1 = static_cast< wxEventType >(val1);
30274 }
30275 if (obj1) {
30276 ecode2 = SWIG_AsVal_int(obj1, &val2);
30277 if (!SWIG_IsOK(ecode2)) {
30278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
30279 }
30280 arg2 = static_cast< int >(val2);
30281 }
30282 {
30283 PyThreadState* __tstate = wxPyBeginAllowThreads();
30284 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
30285 wxPyEndAllowThreads(__tstate);
30286 if (PyErr_Occurred()) SWIG_fail;
30287 }
30288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30296 PyObject *resultobj = 0;
30297 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30298 void *argp1 = 0 ;
30299 int res1 = 0 ;
30300 PyObject *swig_obj[1] ;
30301
30302 if (!args) SWIG_fail;
30303 swig_obj[0] = args;
30304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
30305 if (!SWIG_IsOK(res1)) {
30306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30307 }
30308 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30309 {
30310 PyThreadState* __tstate = wxPyBeginAllowThreads();
30311 delete arg1;
30312
30313 wxPyEndAllowThreads(__tstate);
30314 if (PyErr_Occurred()) SWIG_fail;
30315 }
30316 resultobj = SWIG_Py_Void();
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30324 PyObject *resultobj = 0;
30325 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30326 PyObject *arg2 = (PyObject *) 0 ;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 PyObject * obj0 = 0 ;
30330 PyObject * obj1 = 0 ;
30331 char * kwnames[] = {
30332 (char *) "self",(char *) "self", NULL
30333 };
30334
30335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30337 if (!SWIG_IsOK(res1)) {
30338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30339 }
30340 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30341 arg2 = obj1;
30342 {
30343 PyThreadState* __tstate = wxPyBeginAllowThreads();
30344 (arg1)->SetSelf(arg2);
30345 wxPyEndAllowThreads(__tstate);
30346 if (PyErr_Occurred()) SWIG_fail;
30347 }
30348 resultobj = SWIG_Py_Void();
30349 return resultobj;
30350 fail:
30351 return NULL;
30352 }
30353
30354
30355 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30356 PyObject *resultobj = 0;
30357 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30358 PyObject *result = 0 ;
30359 void *argp1 = 0 ;
30360 int res1 = 0 ;
30361 PyObject *swig_obj[1] ;
30362
30363 if (!args) SWIG_fail;
30364 swig_obj[0] = args;
30365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30366 if (!SWIG_IsOK(res1)) {
30367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30368 }
30369 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30370 {
30371 PyThreadState* __tstate = wxPyBeginAllowThreads();
30372 result = (PyObject *)(arg1)->GetSelf();
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 resultobj = result;
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30384 PyObject *obj;
30385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30386 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
30387 return SWIG_Py_Void();
30388 }
30389
30390 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30391 return SWIG_Python_InitShadowInstance(args);
30392 }
30393
30394 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30395 PyObject *resultobj = 0;
30396 wxWindow *arg1 = (wxWindow *) 0 ;
30397 wxDateTime *arg2 = 0 ;
30398 wxEventType arg3 ;
30399 wxDateEvent *result = 0 ;
30400 void *argp1 = 0 ;
30401 int res1 = 0 ;
30402 void *argp2 = 0 ;
30403 int res2 = 0 ;
30404 int val3 ;
30405 int ecode3 = 0 ;
30406 PyObject * obj0 = 0 ;
30407 PyObject * obj1 = 0 ;
30408 PyObject * obj2 = 0 ;
30409 char * kwnames[] = {
30410 (char *) "win",(char *) "dt",(char *) "type", NULL
30411 };
30412
30413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30415 if (!SWIG_IsOK(res1)) {
30416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
30417 }
30418 arg1 = reinterpret_cast< wxWindow * >(argp1);
30419 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30420 if (!SWIG_IsOK(res2)) {
30421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30422 }
30423 if (!argp2) {
30424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30425 }
30426 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30427 ecode3 = SWIG_AsVal_int(obj2, &val3);
30428 if (!SWIG_IsOK(ecode3)) {
30429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
30430 }
30431 arg3 = static_cast< wxEventType >(val3);
30432 {
30433 PyThreadState* __tstate = wxPyBeginAllowThreads();
30434 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
30435 wxPyEndAllowThreads(__tstate);
30436 if (PyErr_Occurred()) SWIG_fail;
30437 }
30438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
30439 return resultobj;
30440 fail:
30441 return NULL;
30442 }
30443
30444
30445 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30446 PyObject *resultobj = 0;
30447 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30448 wxDateTime *result = 0 ;
30449 void *argp1 = 0 ;
30450 int res1 = 0 ;
30451 PyObject *swig_obj[1] ;
30452
30453 if (!args) SWIG_fail;
30454 swig_obj[0] = args;
30455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30456 if (!SWIG_IsOK(res1)) {
30457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
30458 }
30459 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30460 {
30461 PyThreadState* __tstate = wxPyBeginAllowThreads();
30462 {
30463 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
30464 result = (wxDateTime *) &_result_ref;
30465 }
30466 wxPyEndAllowThreads(__tstate);
30467 if (PyErr_Occurred()) SWIG_fail;
30468 }
30469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
30470 return resultobj;
30471 fail:
30472 return NULL;
30473 }
30474
30475
30476 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30477 PyObject *resultobj = 0;
30478 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30479 wxDateTime *arg2 = 0 ;
30480 void *argp1 = 0 ;
30481 int res1 = 0 ;
30482 void *argp2 = 0 ;
30483 int res2 = 0 ;
30484 PyObject * obj0 = 0 ;
30485 PyObject * obj1 = 0 ;
30486 char * kwnames[] = {
30487 (char *) "self",(char *) "date", NULL
30488 };
30489
30490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
30491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30492 if (!SWIG_IsOK(res1)) {
30493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
30494 }
30495 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30496 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30497 if (!SWIG_IsOK(res2)) {
30498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30499 }
30500 if (!argp2) {
30501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30502 }
30503 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 (arg1)->SetDate((wxDateTime const &)*arg2);
30507 wxPyEndAllowThreads(__tstate);
30508 if (PyErr_Occurred()) SWIG_fail;
30509 }
30510 resultobj = SWIG_Py_Void();
30511 return resultobj;
30512 fail:
30513 return NULL;
30514 }
30515
30516
30517 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30518 PyObject *obj;
30519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30520 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
30521 return SWIG_Py_Void();
30522 }
30523
30524 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30525 return SWIG_Python_InitShadowInstance(args);
30526 }
30527
30528 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30529 PyObject *resultobj = 0;
30530 wxWindow *arg1 = (wxWindow *) 0 ;
30531 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
30532 wxEventBlocker *result = 0 ;
30533 void *argp1 = 0 ;
30534 int res1 = 0 ;
30535 int val2 ;
30536 int ecode2 = 0 ;
30537 PyObject * obj0 = 0 ;
30538 PyObject * obj1 = 0 ;
30539 char * kwnames[] = {
30540 (char *) "win",(char *) "type", NULL
30541 };
30542
30543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30545 if (!SWIG_IsOK(res1)) {
30546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30547 }
30548 arg1 = reinterpret_cast< wxWindow * >(argp1);
30549 if (obj1) {
30550 ecode2 = SWIG_AsVal_int(obj1, &val2);
30551 if (!SWIG_IsOK(ecode2)) {
30552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30553 }
30554 arg2 = static_cast< wxEventType >(val2);
30555 }
30556 {
30557 PyThreadState* __tstate = wxPyBeginAllowThreads();
30558 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30559 wxPyEndAllowThreads(__tstate);
30560 if (PyErr_Occurred()) SWIG_fail;
30561 }
30562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30563 return resultobj;
30564 fail:
30565 return NULL;
30566 }
30567
30568
30569 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30570 PyObject *resultobj = 0;
30571 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30572 void *argp1 = 0 ;
30573 int res1 = 0 ;
30574 PyObject *swig_obj[1] ;
30575
30576 if (!args) SWIG_fail;
30577 swig_obj[0] = args;
30578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30579 if (!SWIG_IsOK(res1)) {
30580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30581 }
30582 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30583 {
30584 PyThreadState* __tstate = wxPyBeginAllowThreads();
30585 delete arg1;
30586
30587 wxPyEndAllowThreads(__tstate);
30588 if (PyErr_Occurred()) SWIG_fail;
30589 }
30590 resultobj = SWIG_Py_Void();
30591 return resultobj;
30592 fail:
30593 return NULL;
30594 }
30595
30596
30597 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30598 PyObject *resultobj = 0;
30599 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30600 wxEventType arg2 ;
30601 void *argp1 = 0 ;
30602 int res1 = 0 ;
30603 int val2 ;
30604 int ecode2 = 0 ;
30605 PyObject * obj0 = 0 ;
30606 PyObject * obj1 = 0 ;
30607 char * kwnames[] = {
30608 (char *) "self",(char *) "type", NULL
30609 };
30610
30611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30613 if (!SWIG_IsOK(res1)) {
30614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30615 }
30616 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30617 ecode2 = SWIG_AsVal_int(obj1, &val2);
30618 if (!SWIG_IsOK(ecode2)) {
30619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30620 }
30621 arg2 = static_cast< wxEventType >(val2);
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 (arg1)->Block(arg2);
30625 wxPyEndAllowThreads(__tstate);
30626 if (PyErr_Occurred()) SWIG_fail;
30627 }
30628 resultobj = SWIG_Py_Void();
30629 return resultobj;
30630 fail:
30631 return NULL;
30632 }
30633
30634
30635 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30636 PyObject *obj;
30637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30638 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30639 return SWIG_Py_Void();
30640 }
30641
30642 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30643 return SWIG_Python_InitShadowInstance(args);
30644 }
30645
30646 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30647 PyObject *resultobj = 0;
30648 wxPyApp *result = 0 ;
30649
30650 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30651 {
30652 PyThreadState* __tstate = wxPyBeginAllowThreads();
30653 result = (wxPyApp *)new_wxPyApp();
30654 wxPyEndAllowThreads(__tstate);
30655 if (PyErr_Occurred()) SWIG_fail;
30656 }
30657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30658 return resultobj;
30659 fail:
30660 return NULL;
30661 }
30662
30663
30664 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30665 PyObject *resultobj = 0;
30666 wxPyApp *arg1 = (wxPyApp *) 0 ;
30667 void *argp1 = 0 ;
30668 int res1 = 0 ;
30669 PyObject *swig_obj[1] ;
30670
30671 if (!args) SWIG_fail;
30672 swig_obj[0] = args;
30673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30674 if (!SWIG_IsOK(res1)) {
30675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30676 }
30677 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30678 {
30679 PyThreadState* __tstate = wxPyBeginAllowThreads();
30680 delete arg1;
30681
30682 wxPyEndAllowThreads(__tstate);
30683 if (PyErr_Occurred()) SWIG_fail;
30684 }
30685 resultobj = SWIG_Py_Void();
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj = 0;
30694 wxPyApp *arg1 = (wxPyApp *) 0 ;
30695 PyObject *arg2 = (PyObject *) 0 ;
30696 PyObject *arg3 = (PyObject *) 0 ;
30697 bool arg4 = (bool) false ;
30698 void *argp1 = 0 ;
30699 int res1 = 0 ;
30700 bool val4 ;
30701 int ecode4 = 0 ;
30702 PyObject * obj0 = 0 ;
30703 PyObject * obj1 = 0 ;
30704 PyObject * obj2 = 0 ;
30705 PyObject * obj3 = 0 ;
30706 char * kwnames[] = {
30707 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30708 };
30709
30710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30712 if (!SWIG_IsOK(res1)) {
30713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30714 }
30715 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30716 arg2 = obj1;
30717 arg3 = obj2;
30718 if (obj3) {
30719 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30720 if (!SWIG_IsOK(ecode4)) {
30721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30722 }
30723 arg4 = static_cast< bool >(val4);
30724 }
30725 {
30726 PyThreadState* __tstate = wxPyBeginAllowThreads();
30727 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30728 wxPyEndAllowThreads(__tstate);
30729 if (PyErr_Occurred()) SWIG_fail;
30730 }
30731 resultobj = SWIG_Py_Void();
30732 return resultobj;
30733 fail:
30734 return NULL;
30735 }
30736
30737
30738 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30739 PyObject *resultobj = 0;
30740 wxPyApp *arg1 = (wxPyApp *) 0 ;
30741 wxString result;
30742 void *argp1 = 0 ;
30743 int res1 = 0 ;
30744 PyObject *swig_obj[1] ;
30745
30746 if (!args) SWIG_fail;
30747 swig_obj[0] = args;
30748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30749 if (!SWIG_IsOK(res1)) {
30750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30751 }
30752 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30753 {
30754 PyThreadState* __tstate = wxPyBeginAllowThreads();
30755 result = ((wxPyApp const *)arg1)->GetAppName();
30756 wxPyEndAllowThreads(__tstate);
30757 if (PyErr_Occurred()) SWIG_fail;
30758 }
30759 {
30760 #if wxUSE_UNICODE
30761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30762 #else
30763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30764 #endif
30765 }
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30773 PyObject *resultobj = 0;
30774 wxPyApp *arg1 = (wxPyApp *) 0 ;
30775 wxString *arg2 = 0 ;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 bool temp2 = false ;
30779 PyObject * obj0 = 0 ;
30780 PyObject * obj1 = 0 ;
30781 char * kwnames[] = {
30782 (char *) "self",(char *) "name", NULL
30783 };
30784
30785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30787 if (!SWIG_IsOK(res1)) {
30788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30789 }
30790 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30791 {
30792 arg2 = wxString_in_helper(obj1);
30793 if (arg2 == NULL) SWIG_fail;
30794 temp2 = true;
30795 }
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 (arg1)->SetAppName((wxString const &)*arg2);
30799 wxPyEndAllowThreads(__tstate);
30800 if (PyErr_Occurred()) SWIG_fail;
30801 }
30802 resultobj = SWIG_Py_Void();
30803 {
30804 if (temp2)
30805 delete arg2;
30806 }
30807 return resultobj;
30808 fail:
30809 {
30810 if (temp2)
30811 delete arg2;
30812 }
30813 return NULL;
30814 }
30815
30816
30817 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30818 PyObject *resultobj = 0;
30819 wxPyApp *arg1 = (wxPyApp *) 0 ;
30820 wxString result;
30821 void *argp1 = 0 ;
30822 int res1 = 0 ;
30823 PyObject *swig_obj[1] ;
30824
30825 if (!args) SWIG_fail;
30826 swig_obj[0] = args;
30827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30828 if (!SWIG_IsOK(res1)) {
30829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30830 }
30831 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30832 {
30833 PyThreadState* __tstate = wxPyBeginAllowThreads();
30834 result = ((wxPyApp const *)arg1)->GetClassName();
30835 wxPyEndAllowThreads(__tstate);
30836 if (PyErr_Occurred()) SWIG_fail;
30837 }
30838 {
30839 #if wxUSE_UNICODE
30840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30841 #else
30842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30843 #endif
30844 }
30845 return resultobj;
30846 fail:
30847 return NULL;
30848 }
30849
30850
30851 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30852 PyObject *resultobj = 0;
30853 wxPyApp *arg1 = (wxPyApp *) 0 ;
30854 wxString *arg2 = 0 ;
30855 void *argp1 = 0 ;
30856 int res1 = 0 ;
30857 bool temp2 = false ;
30858 PyObject * obj0 = 0 ;
30859 PyObject * obj1 = 0 ;
30860 char * kwnames[] = {
30861 (char *) "self",(char *) "name", NULL
30862 };
30863
30864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30868 }
30869 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30870 {
30871 arg2 = wxString_in_helper(obj1);
30872 if (arg2 == NULL) SWIG_fail;
30873 temp2 = true;
30874 }
30875 {
30876 PyThreadState* __tstate = wxPyBeginAllowThreads();
30877 (arg1)->SetClassName((wxString const &)*arg2);
30878 wxPyEndAllowThreads(__tstate);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 }
30881 resultobj = SWIG_Py_Void();
30882 {
30883 if (temp2)
30884 delete arg2;
30885 }
30886 return resultobj;
30887 fail:
30888 {
30889 if (temp2)
30890 delete arg2;
30891 }
30892 return NULL;
30893 }
30894
30895
30896 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30897 PyObject *resultobj = 0;
30898 wxPyApp *arg1 = (wxPyApp *) 0 ;
30899 wxString *result = 0 ;
30900 void *argp1 = 0 ;
30901 int res1 = 0 ;
30902 PyObject *swig_obj[1] ;
30903
30904 if (!args) SWIG_fail;
30905 swig_obj[0] = args;
30906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30907 if (!SWIG_IsOK(res1)) {
30908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30909 }
30910 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 {
30914 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30915 result = (wxString *) &_result_ref;
30916 }
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 {
30921 #if wxUSE_UNICODE
30922 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30923 #else
30924 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30925 #endif
30926 }
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30934 PyObject *resultobj = 0;
30935 wxPyApp *arg1 = (wxPyApp *) 0 ;
30936 wxString *arg2 = 0 ;
30937 void *argp1 = 0 ;
30938 int res1 = 0 ;
30939 bool temp2 = false ;
30940 PyObject * obj0 = 0 ;
30941 PyObject * obj1 = 0 ;
30942 char * kwnames[] = {
30943 (char *) "self",(char *) "name", NULL
30944 };
30945
30946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30948 if (!SWIG_IsOK(res1)) {
30949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30950 }
30951 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30952 {
30953 arg2 = wxString_in_helper(obj1);
30954 if (arg2 == NULL) SWIG_fail;
30955 temp2 = true;
30956 }
30957 {
30958 PyThreadState* __tstate = wxPyBeginAllowThreads();
30959 (arg1)->SetVendorName((wxString const &)*arg2);
30960 wxPyEndAllowThreads(__tstate);
30961 if (PyErr_Occurred()) SWIG_fail;
30962 }
30963 resultobj = SWIG_Py_Void();
30964 {
30965 if (temp2)
30966 delete arg2;
30967 }
30968 return resultobj;
30969 fail:
30970 {
30971 if (temp2)
30972 delete arg2;
30973 }
30974 return NULL;
30975 }
30976
30977
30978 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30979 PyObject *resultobj = 0;
30980 wxPyApp *arg1 = (wxPyApp *) 0 ;
30981 wxAppTraits *result = 0 ;
30982 void *argp1 = 0 ;
30983 int res1 = 0 ;
30984 PyObject *swig_obj[1] ;
30985
30986 if (!args) SWIG_fail;
30987 swig_obj[0] = args;
30988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30989 if (!SWIG_IsOK(res1)) {
30990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30991 }
30992 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30993 {
30994 PyThreadState* __tstate = wxPyBeginAllowThreads();
30995 result = (wxAppTraits *)(arg1)->GetTraits();
30996 wxPyEndAllowThreads(__tstate);
30997 if (PyErr_Occurred()) SWIG_fail;
30998 }
30999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
31000 return resultobj;
31001 fail:
31002 return NULL;
31003 }
31004
31005
31006 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31007 PyObject *resultobj = 0;
31008 wxPyApp *arg1 = (wxPyApp *) 0 ;
31009 void *argp1 = 0 ;
31010 int res1 = 0 ;
31011 PyObject *swig_obj[1] ;
31012
31013 if (!args) SWIG_fail;
31014 swig_obj[0] = args;
31015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31016 if (!SWIG_IsOK(res1)) {
31017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31018 }
31019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31020 {
31021 PyThreadState* __tstate = wxPyBeginAllowThreads();
31022 (arg1)->ProcessPendingEvents();
31023 wxPyEndAllowThreads(__tstate);
31024 if (PyErr_Occurred()) SWIG_fail;
31025 }
31026 resultobj = SWIG_Py_Void();
31027 return resultobj;
31028 fail:
31029 return NULL;
31030 }
31031
31032
31033 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31034 PyObject *resultobj = 0;
31035 wxPyApp *arg1 = (wxPyApp *) 0 ;
31036 bool arg2 = (bool) false ;
31037 bool result;
31038 void *argp1 = 0 ;
31039 int res1 = 0 ;
31040 bool val2 ;
31041 int ecode2 = 0 ;
31042 PyObject * obj0 = 0 ;
31043 PyObject * obj1 = 0 ;
31044 char * kwnames[] = {
31045 (char *) "self",(char *) "onlyIfNeeded", NULL
31046 };
31047
31048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
31049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31050 if (!SWIG_IsOK(res1)) {
31051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
31052 }
31053 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31054 if (obj1) {
31055 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31056 if (!SWIG_IsOK(ecode2)) {
31057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
31058 }
31059 arg2 = static_cast< bool >(val2);
31060 }
31061 {
31062 PyThreadState* __tstate = wxPyBeginAllowThreads();
31063 result = (bool)(arg1)->Yield(arg2);
31064 wxPyEndAllowThreads(__tstate);
31065 if (PyErr_Occurred()) SWIG_fail;
31066 }
31067 {
31068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31069 }
31070 return resultobj;
31071 fail:
31072 return NULL;
31073 }
31074
31075
31076 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31077 PyObject *resultobj = 0;
31078 wxPyApp *arg1 = (wxPyApp *) 0 ;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 PyObject *swig_obj[1] ;
31082
31083 if (!args) SWIG_fail;
31084 swig_obj[0] = args;
31085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31086 if (!SWIG_IsOK(res1)) {
31087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31088 }
31089 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 (arg1)->WakeUpIdle();
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 resultobj = SWIG_Py_Void();
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31104 PyObject *resultobj = 0;
31105 bool result;
31106
31107 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
31108 {
31109 PyThreadState* __tstate = wxPyBeginAllowThreads();
31110 result = (bool)wxPyApp::IsMainLoopRunning();
31111 wxPyEndAllowThreads(__tstate);
31112 if (PyErr_Occurred()) SWIG_fail;
31113 }
31114 {
31115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31116 }
31117 return resultobj;
31118 fail:
31119 return NULL;
31120 }
31121
31122
31123 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31124 PyObject *resultobj = 0;
31125 wxPyApp *arg1 = (wxPyApp *) 0 ;
31126 int result;
31127 void *argp1 = 0 ;
31128 int res1 = 0 ;
31129 PyObject *swig_obj[1] ;
31130
31131 if (!args) SWIG_fail;
31132 swig_obj[0] = args;
31133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31134 if (!SWIG_IsOK(res1)) {
31135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31136 }
31137 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31138 {
31139 PyThreadState* __tstate = wxPyBeginAllowThreads();
31140 result = (int)(arg1)->MainLoop();
31141 wxPyEndAllowThreads(__tstate);
31142 if (PyErr_Occurred()) SWIG_fail;
31143 }
31144 resultobj = SWIG_From_int(static_cast< int >(result));
31145 return resultobj;
31146 fail:
31147 return NULL;
31148 }
31149
31150
31151 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31152 PyObject *resultobj = 0;
31153 wxPyApp *arg1 = (wxPyApp *) 0 ;
31154 void *argp1 = 0 ;
31155 int res1 = 0 ;
31156 PyObject *swig_obj[1] ;
31157
31158 if (!args) SWIG_fail;
31159 swig_obj[0] = args;
31160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31161 if (!SWIG_IsOK(res1)) {
31162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
31163 }
31164 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 (arg1)->Exit();
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 resultobj = SWIG_Py_Void();
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31179 PyObject *resultobj = 0;
31180 wxPyApp *arg1 = (wxPyApp *) 0 ;
31181 wxLayoutDirection result;
31182 void *argp1 = 0 ;
31183 int res1 = 0 ;
31184 PyObject *swig_obj[1] ;
31185
31186 if (!args) SWIG_fail;
31187 swig_obj[0] = args;
31188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31189 if (!SWIG_IsOK(res1)) {
31190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31191 }
31192 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 resultobj = SWIG_From_int(static_cast< int >(result));
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31207 PyObject *resultobj = 0;
31208 wxPyApp *arg1 = (wxPyApp *) 0 ;
31209 void *argp1 = 0 ;
31210 int res1 = 0 ;
31211 PyObject *swig_obj[1] ;
31212
31213 if (!args) SWIG_fail;
31214 swig_obj[0] = args;
31215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31216 if (!SWIG_IsOK(res1)) {
31217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31218 }
31219 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31220 {
31221 PyThreadState* __tstate = wxPyBeginAllowThreads();
31222 (arg1)->ExitMainLoop();
31223 wxPyEndAllowThreads(__tstate);
31224 if (PyErr_Occurred()) SWIG_fail;
31225 }
31226 resultobj = SWIG_Py_Void();
31227 return resultobj;
31228 fail:
31229 return NULL;
31230 }
31231
31232
31233 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31234 PyObject *resultobj = 0;
31235 wxPyApp *arg1 = (wxPyApp *) 0 ;
31236 bool result;
31237 void *argp1 = 0 ;
31238 int res1 = 0 ;
31239 PyObject *swig_obj[1] ;
31240
31241 if (!args) SWIG_fail;
31242 swig_obj[0] = args;
31243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31244 if (!SWIG_IsOK(res1)) {
31245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
31246 }
31247 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31248 {
31249 PyThreadState* __tstate = wxPyBeginAllowThreads();
31250 result = (bool)(arg1)->Pending();
31251 wxPyEndAllowThreads(__tstate);
31252 if (PyErr_Occurred()) SWIG_fail;
31253 }
31254 {
31255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31256 }
31257 return resultobj;
31258 fail:
31259 return NULL;
31260 }
31261
31262
31263 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31264 PyObject *resultobj = 0;
31265 wxPyApp *arg1 = (wxPyApp *) 0 ;
31266 bool result;
31267 void *argp1 = 0 ;
31268 int res1 = 0 ;
31269 PyObject *swig_obj[1] ;
31270
31271 if (!args) SWIG_fail;
31272 swig_obj[0] = args;
31273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31274 if (!SWIG_IsOK(res1)) {
31275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
31276 }
31277 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31278 {
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 result = (bool)(arg1)->Dispatch();
31281 wxPyEndAllowThreads(__tstate);
31282 if (PyErr_Occurred()) SWIG_fail;
31283 }
31284 {
31285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31286 }
31287 return resultobj;
31288 fail:
31289 return NULL;
31290 }
31291
31292
31293 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31294 PyObject *resultobj = 0;
31295 wxPyApp *arg1 = (wxPyApp *) 0 ;
31296 bool result;
31297 void *argp1 = 0 ;
31298 int res1 = 0 ;
31299 PyObject *swig_obj[1] ;
31300
31301 if (!args) SWIG_fail;
31302 swig_obj[0] = args;
31303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31304 if (!SWIG_IsOK(res1)) {
31305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31306 }
31307 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31308 {
31309 PyThreadState* __tstate = wxPyBeginAllowThreads();
31310 result = (bool)(arg1)->ProcessIdle();
31311 wxPyEndAllowThreads(__tstate);
31312 if (PyErr_Occurred()) SWIG_fail;
31313 }
31314 {
31315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31316 }
31317 return resultobj;
31318 fail:
31319 return NULL;
31320 }
31321
31322
31323 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31324 PyObject *resultobj = 0;
31325 wxPyApp *arg1 = (wxPyApp *) 0 ;
31326 wxWindow *arg2 = (wxWindow *) 0 ;
31327 wxIdleEvent *arg3 = 0 ;
31328 bool result;
31329 void *argp1 = 0 ;
31330 int res1 = 0 ;
31331 void *argp2 = 0 ;
31332 int res2 = 0 ;
31333 void *argp3 = 0 ;
31334 int res3 = 0 ;
31335 PyObject * obj0 = 0 ;
31336 PyObject * obj1 = 0 ;
31337 PyObject * obj2 = 0 ;
31338 char * kwnames[] = {
31339 (char *) "self",(char *) "win",(char *) "event", NULL
31340 };
31341
31342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31344 if (!SWIG_IsOK(res1)) {
31345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31346 }
31347 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31348 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31349 if (!SWIG_IsOK(res2)) {
31350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
31351 }
31352 arg2 = reinterpret_cast< wxWindow * >(argp2);
31353 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
31354 if (!SWIG_IsOK(res3)) {
31355 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31356 }
31357 if (!argp3) {
31358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31359 }
31360 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
31361 {
31362 PyThreadState* __tstate = wxPyBeginAllowThreads();
31363 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
31364 wxPyEndAllowThreads(__tstate);
31365 if (PyErr_Occurred()) SWIG_fail;
31366 }
31367 {
31368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31369 }
31370 return resultobj;
31371 fail:
31372 return NULL;
31373 }
31374
31375
31376 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31377 PyObject *resultobj = 0;
31378 wxPyApp *arg1 = (wxPyApp *) 0 ;
31379 bool result;
31380 void *argp1 = 0 ;
31381 int res1 = 0 ;
31382 PyObject *swig_obj[1] ;
31383
31384 if (!args) SWIG_fail;
31385 swig_obj[0] = args;
31386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31387 if (!SWIG_IsOK(res1)) {
31388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31389 }
31390 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31391 {
31392 PyThreadState* __tstate = wxPyBeginAllowThreads();
31393 result = (bool)((wxPyApp const *)arg1)->IsActive();
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 {
31398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31399 }
31400 return resultobj;
31401 fail:
31402 return NULL;
31403 }
31404
31405
31406 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31407 PyObject *resultobj = 0;
31408 wxPyApp *arg1 = (wxPyApp *) 0 ;
31409 wxWindow *arg2 = (wxWindow *) 0 ;
31410 void *argp1 = 0 ;
31411 int res1 = 0 ;
31412 void *argp2 = 0 ;
31413 int res2 = 0 ;
31414 PyObject * obj0 = 0 ;
31415 PyObject * obj1 = 0 ;
31416 char * kwnames[] = {
31417 (char *) "self",(char *) "win", NULL
31418 };
31419
31420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
31421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31422 if (!SWIG_IsOK(res1)) {
31423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
31424 }
31425 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31427 if (!SWIG_IsOK(res2)) {
31428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
31429 }
31430 arg2 = reinterpret_cast< wxWindow * >(argp2);
31431 {
31432 PyThreadState* __tstate = wxPyBeginAllowThreads();
31433 (arg1)->SetTopWindow(arg2);
31434 wxPyEndAllowThreads(__tstate);
31435 if (PyErr_Occurred()) SWIG_fail;
31436 }
31437 resultobj = SWIG_Py_Void();
31438 return resultobj;
31439 fail:
31440 return NULL;
31441 }
31442
31443
31444 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31445 PyObject *resultobj = 0;
31446 wxPyApp *arg1 = (wxPyApp *) 0 ;
31447 wxWindow *result = 0 ;
31448 void *argp1 = 0 ;
31449 int res1 = 0 ;
31450 PyObject *swig_obj[1] ;
31451
31452 if (!args) SWIG_fail;
31453 swig_obj[0] = args;
31454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31455 if (!SWIG_IsOK(res1)) {
31456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31457 }
31458 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 {
31466 resultobj = wxPyMake_wxObject(result, (bool)0);
31467 }
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31475 PyObject *resultobj = 0;
31476 wxPyApp *arg1 = (wxPyApp *) 0 ;
31477 bool arg2 ;
31478 void *argp1 = 0 ;
31479 int res1 = 0 ;
31480 bool val2 ;
31481 int ecode2 = 0 ;
31482 PyObject * obj0 = 0 ;
31483 PyObject * obj1 = 0 ;
31484 char * kwnames[] = {
31485 (char *) "self",(char *) "flag", NULL
31486 };
31487
31488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
31489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31490 if (!SWIG_IsOK(res1)) {
31491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
31492 }
31493 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31494 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31495 if (!SWIG_IsOK(ecode2)) {
31496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
31497 }
31498 arg2 = static_cast< bool >(val2);
31499 {
31500 PyThreadState* __tstate = wxPyBeginAllowThreads();
31501 (arg1)->SetExitOnFrameDelete(arg2);
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 resultobj = SWIG_Py_Void();
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31513 PyObject *resultobj = 0;
31514 wxPyApp *arg1 = (wxPyApp *) 0 ;
31515 bool result;
31516 void *argp1 = 0 ;
31517 int res1 = 0 ;
31518 PyObject *swig_obj[1] ;
31519
31520 if (!args) SWIG_fail;
31521 swig_obj[0] = args;
31522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31523 if (!SWIG_IsOK(res1)) {
31524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31525 }
31526 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31527 {
31528 PyThreadState* __tstate = wxPyBeginAllowThreads();
31529 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
31530 wxPyEndAllowThreads(__tstate);
31531 if (PyErr_Occurred()) SWIG_fail;
31532 }
31533 {
31534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31535 }
31536 return resultobj;
31537 fail:
31538 return NULL;
31539 }
31540
31541
31542 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj = 0;
31544 wxPyApp *arg1 = (wxPyApp *) 0 ;
31545 bool arg2 ;
31546 bool arg3 = (bool) false ;
31547 void *argp1 = 0 ;
31548 int res1 = 0 ;
31549 bool val2 ;
31550 int ecode2 = 0 ;
31551 bool val3 ;
31552 int ecode3 = 0 ;
31553 PyObject * obj0 = 0 ;
31554 PyObject * obj1 = 0 ;
31555 PyObject * obj2 = 0 ;
31556 char * kwnames[] = {
31557 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31558 };
31559
31560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31562 if (!SWIG_IsOK(res1)) {
31563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31564 }
31565 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31566 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31567 if (!SWIG_IsOK(ecode2)) {
31568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31569 }
31570 arg2 = static_cast< bool >(val2);
31571 if (obj2) {
31572 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31573 if (!SWIG_IsOK(ecode3)) {
31574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31575 }
31576 arg3 = static_cast< bool >(val3);
31577 }
31578 {
31579 PyThreadState* __tstate = wxPyBeginAllowThreads();
31580 (arg1)->SetUseBestVisual(arg2,arg3);
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 resultobj = SWIG_Py_Void();
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31592 PyObject *resultobj = 0;
31593 wxPyApp *arg1 = (wxPyApp *) 0 ;
31594 bool result;
31595 void *argp1 = 0 ;
31596 int res1 = 0 ;
31597 PyObject *swig_obj[1] ;
31598
31599 if (!args) SWIG_fail;
31600 swig_obj[0] = args;
31601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31602 if (!SWIG_IsOK(res1)) {
31603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31604 }
31605 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31609 wxPyEndAllowThreads(__tstate);
31610 if (PyErr_Occurred()) SWIG_fail;
31611 }
31612 {
31613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31614 }
31615 return resultobj;
31616 fail:
31617 return NULL;
31618 }
31619
31620
31621 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31622 PyObject *resultobj = 0;
31623 wxPyApp *arg1 = (wxPyApp *) 0 ;
31624 int arg2 ;
31625 void *argp1 = 0 ;
31626 int res1 = 0 ;
31627 int val2 ;
31628 int ecode2 = 0 ;
31629 PyObject * obj0 = 0 ;
31630 PyObject * obj1 = 0 ;
31631 char * kwnames[] = {
31632 (char *) "self",(char *) "mode", NULL
31633 };
31634
31635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31637 if (!SWIG_IsOK(res1)) {
31638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31639 }
31640 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31641 ecode2 = SWIG_AsVal_int(obj1, &val2);
31642 if (!SWIG_IsOK(ecode2)) {
31643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31644 }
31645 arg2 = static_cast< int >(val2);
31646 {
31647 PyThreadState* __tstate = wxPyBeginAllowThreads();
31648 (arg1)->SetPrintMode(arg2);
31649 wxPyEndAllowThreads(__tstate);
31650 if (PyErr_Occurred()) SWIG_fail;
31651 }
31652 resultobj = SWIG_Py_Void();
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31660 PyObject *resultobj = 0;
31661 wxPyApp *arg1 = (wxPyApp *) 0 ;
31662 int result;
31663 void *argp1 = 0 ;
31664 int res1 = 0 ;
31665 PyObject *swig_obj[1] ;
31666
31667 if (!args) SWIG_fail;
31668 swig_obj[0] = args;
31669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31670 if (!SWIG_IsOK(res1)) {
31671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31672 }
31673 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31674 {
31675 PyThreadState* __tstate = wxPyBeginAllowThreads();
31676 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31677 wxPyEndAllowThreads(__tstate);
31678 if (PyErr_Occurred()) SWIG_fail;
31679 }
31680 resultobj = SWIG_From_int(static_cast< int >(result));
31681 return resultobj;
31682 fail:
31683 return NULL;
31684 }
31685
31686
31687 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31688 PyObject *resultobj = 0;
31689 wxPyApp *arg1 = (wxPyApp *) 0 ;
31690 int arg2 ;
31691 void *argp1 = 0 ;
31692 int res1 = 0 ;
31693 int val2 ;
31694 int ecode2 = 0 ;
31695 PyObject * obj0 = 0 ;
31696 PyObject * obj1 = 0 ;
31697 char * kwnames[] = {
31698 (char *) "self",(char *) "mode", NULL
31699 };
31700
31701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31703 if (!SWIG_IsOK(res1)) {
31704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31705 }
31706 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31707 ecode2 = SWIG_AsVal_int(obj1, &val2);
31708 if (!SWIG_IsOK(ecode2)) {
31709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31710 }
31711 arg2 = static_cast< int >(val2);
31712 {
31713 PyThreadState* __tstate = wxPyBeginAllowThreads();
31714 (arg1)->SetAssertMode(arg2);
31715 wxPyEndAllowThreads(__tstate);
31716 if (PyErr_Occurred()) SWIG_fail;
31717 }
31718 resultobj = SWIG_Py_Void();
31719 return resultobj;
31720 fail:
31721 return NULL;
31722 }
31723
31724
31725 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31726 PyObject *resultobj = 0;
31727 wxPyApp *arg1 = (wxPyApp *) 0 ;
31728 int result;
31729 void *argp1 = 0 ;
31730 int res1 = 0 ;
31731 PyObject *swig_obj[1] ;
31732
31733 if (!args) SWIG_fail;
31734 swig_obj[0] = args;
31735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31736 if (!SWIG_IsOK(res1)) {
31737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31738 }
31739 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31740 {
31741 PyThreadState* __tstate = wxPyBeginAllowThreads();
31742 result = (int)(arg1)->GetAssertMode();
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 resultobj = SWIG_From_int(static_cast< int >(result));
31747 return resultobj;
31748 fail:
31749 return NULL;
31750 }
31751
31752
31753 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31754 PyObject *resultobj = 0;
31755 bool result;
31756
31757 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31758 {
31759 PyThreadState* __tstate = wxPyBeginAllowThreads();
31760 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31761 wxPyEndAllowThreads(__tstate);
31762 if (PyErr_Occurred()) SWIG_fail;
31763 }
31764 {
31765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31766 }
31767 return resultobj;
31768 fail:
31769 return NULL;
31770 }
31771
31772
31773 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31774 PyObject *resultobj = 0;
31775 long result;
31776
31777 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31778 {
31779 PyThreadState* __tstate = wxPyBeginAllowThreads();
31780 result = (long)wxPyApp::GetMacAboutMenuItemId();
31781 wxPyEndAllowThreads(__tstate);
31782 if (PyErr_Occurred()) SWIG_fail;
31783 }
31784 resultobj = SWIG_From_long(static_cast< long >(result));
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31792 PyObject *resultobj = 0;
31793 long result;
31794
31795 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31796 {
31797 PyThreadState* __tstate = wxPyBeginAllowThreads();
31798 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31799 wxPyEndAllowThreads(__tstate);
31800 if (PyErr_Occurred()) SWIG_fail;
31801 }
31802 resultobj = SWIG_From_long(static_cast< long >(result));
31803 return resultobj;
31804 fail:
31805 return NULL;
31806 }
31807
31808
31809 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31810 PyObject *resultobj = 0;
31811 long result;
31812
31813 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31814 {
31815 PyThreadState* __tstate = wxPyBeginAllowThreads();
31816 result = (long)wxPyApp::GetMacExitMenuItemId();
31817 wxPyEndAllowThreads(__tstate);
31818 if (PyErr_Occurred()) SWIG_fail;
31819 }
31820 resultobj = SWIG_From_long(static_cast< long >(result));
31821 return resultobj;
31822 fail:
31823 return NULL;
31824 }
31825
31826
31827 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31828 PyObject *resultobj = 0;
31829 wxString result;
31830
31831 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31832 {
31833 PyThreadState* __tstate = wxPyBeginAllowThreads();
31834 result = wxPyApp::GetMacHelpMenuTitleName();
31835 wxPyEndAllowThreads(__tstate);
31836 if (PyErr_Occurred()) SWIG_fail;
31837 }
31838 {
31839 #if wxUSE_UNICODE
31840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31841 #else
31842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31843 #endif
31844 }
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31852 PyObject *resultobj = 0;
31853 bool arg1 ;
31854 bool val1 ;
31855 int ecode1 = 0 ;
31856 PyObject * obj0 = 0 ;
31857 char * kwnames[] = {
31858 (char *) "val", NULL
31859 };
31860
31861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31862 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31863 if (!SWIG_IsOK(ecode1)) {
31864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31865 }
31866 arg1 = static_cast< bool >(val1);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_Py_Void();
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31881 PyObject *resultobj = 0;
31882 long arg1 ;
31883 long val1 ;
31884 int ecode1 = 0 ;
31885 PyObject * obj0 = 0 ;
31886 char * kwnames[] = {
31887 (char *) "val", NULL
31888 };
31889
31890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31891 ecode1 = SWIG_AsVal_long(obj0, &val1);
31892 if (!SWIG_IsOK(ecode1)) {
31893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31894 }
31895 arg1 = static_cast< long >(val1);
31896 {
31897 PyThreadState* __tstate = wxPyBeginAllowThreads();
31898 wxPyApp::SetMacAboutMenuItemId(arg1);
31899 wxPyEndAllowThreads(__tstate);
31900 if (PyErr_Occurred()) SWIG_fail;
31901 }
31902 resultobj = SWIG_Py_Void();
31903 return resultobj;
31904 fail:
31905 return NULL;
31906 }
31907
31908
31909 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31910 PyObject *resultobj = 0;
31911 long arg1 ;
31912 long val1 ;
31913 int ecode1 = 0 ;
31914 PyObject * obj0 = 0 ;
31915 char * kwnames[] = {
31916 (char *) "val", NULL
31917 };
31918
31919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31920 ecode1 = SWIG_AsVal_long(obj0, &val1);
31921 if (!SWIG_IsOK(ecode1)) {
31922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31923 }
31924 arg1 = static_cast< long >(val1);
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_Py_Void();
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31939 PyObject *resultobj = 0;
31940 long arg1 ;
31941 long val1 ;
31942 int ecode1 = 0 ;
31943 PyObject * obj0 = 0 ;
31944 char * kwnames[] = {
31945 (char *) "val", NULL
31946 };
31947
31948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31949 ecode1 = SWIG_AsVal_long(obj0, &val1);
31950 if (!SWIG_IsOK(ecode1)) {
31951 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31952 }
31953 arg1 = static_cast< long >(val1);
31954 {
31955 PyThreadState* __tstate = wxPyBeginAllowThreads();
31956 wxPyApp::SetMacExitMenuItemId(arg1);
31957 wxPyEndAllowThreads(__tstate);
31958 if (PyErr_Occurred()) SWIG_fail;
31959 }
31960 resultobj = SWIG_Py_Void();
31961 return resultobj;
31962 fail:
31963 return NULL;
31964 }
31965
31966
31967 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31968 PyObject *resultobj = 0;
31969 wxString *arg1 = 0 ;
31970 bool temp1 = false ;
31971 PyObject * obj0 = 0 ;
31972 char * kwnames[] = {
31973 (char *) "val", NULL
31974 };
31975
31976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31977 {
31978 arg1 = wxString_in_helper(obj0);
31979 if (arg1 == NULL) SWIG_fail;
31980 temp1 = true;
31981 }
31982 {
31983 PyThreadState* __tstate = wxPyBeginAllowThreads();
31984 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31985 wxPyEndAllowThreads(__tstate);
31986 if (PyErr_Occurred()) SWIG_fail;
31987 }
31988 resultobj = SWIG_Py_Void();
31989 {
31990 if (temp1)
31991 delete arg1;
31992 }
31993 return resultobj;
31994 fail:
31995 {
31996 if (temp1)
31997 delete arg1;
31998 }
31999 return NULL;
32000 }
32001
32002
32003 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32004 PyObject *resultobj = 0;
32005 wxPyApp *arg1 = (wxPyApp *) 0 ;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 PyObject *swig_obj[1] ;
32009
32010 if (!args) SWIG_fail;
32011 swig_obj[0] = args;
32012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
32015 }
32016 arg1 = reinterpret_cast< wxPyApp * >(argp1);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 (arg1)->_BootstrapApp();
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_Py_Void();
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32031 PyObject *resultobj = 0;
32032 int result;
32033
32034 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
32035 {
32036 PyThreadState* __tstate = wxPyBeginAllowThreads();
32037 result = (int)wxPyApp::GetComCtl32Version();
32038 wxPyEndAllowThreads(__tstate);
32039 if (PyErr_Occurred()) SWIG_fail;
32040 }
32041 resultobj = SWIG_From_int(static_cast< int >(result));
32042 return resultobj;
32043 fail:
32044 return NULL;
32045 }
32046
32047
32048 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32049 PyObject *resultobj = 0;
32050 bool result;
32051
32052 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
32053 {
32054 PyThreadState* __tstate = wxPyBeginAllowThreads();
32055 result = (bool)wxPyApp_IsDisplayAvailable();
32056 wxPyEndAllowThreads(__tstate);
32057 if (PyErr_Occurred()) SWIG_fail;
32058 }
32059 {
32060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32061 }
32062 return resultobj;
32063 fail:
32064 return NULL;
32065 }
32066
32067
32068 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32069 PyObject *obj;
32070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32071 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
32072 return SWIG_Py_Void();
32073 }
32074
32075 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32076 return SWIG_Python_InitShadowInstance(args);
32077 }
32078
32079 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32080 PyObject *resultobj = 0;
32081
32082 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
32083 {
32084 PyThreadState* __tstate = wxPyBeginAllowThreads();
32085 wxExit();
32086 wxPyEndAllowThreads(__tstate);
32087 if (PyErr_Occurred()) SWIG_fail;
32088 }
32089 resultobj = SWIG_Py_Void();
32090 return resultobj;
32091 fail:
32092 return NULL;
32093 }
32094
32095
32096 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32097 PyObject *resultobj = 0;
32098 bool result;
32099
32100 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
32101 {
32102 PyThreadState* __tstate = wxPyBeginAllowThreads();
32103 result = (bool)wxYield();
32104 wxPyEndAllowThreads(__tstate);
32105 if (PyErr_Occurred()) SWIG_fail;
32106 }
32107 {
32108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32109 }
32110 return resultobj;
32111 fail:
32112 return NULL;
32113 }
32114
32115
32116 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 PyObject *resultobj = 0;
32118 bool result;
32119
32120 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
32121 {
32122 PyThreadState* __tstate = wxPyBeginAllowThreads();
32123 result = (bool)wxYieldIfNeeded();
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 {
32128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32129 }
32130 return resultobj;
32131 fail:
32132 return NULL;
32133 }
32134
32135
32136 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32137 PyObject *resultobj = 0;
32138 wxWindow *arg1 = (wxWindow *) NULL ;
32139 bool arg2 = (bool) false ;
32140 bool result;
32141 void *argp1 = 0 ;
32142 int res1 = 0 ;
32143 bool val2 ;
32144 int ecode2 = 0 ;
32145 PyObject * obj0 = 0 ;
32146 PyObject * obj1 = 0 ;
32147 char * kwnames[] = {
32148 (char *) "win",(char *) "onlyIfNeeded", NULL
32149 };
32150
32151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
32152 if (obj0) {
32153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32154 if (!SWIG_IsOK(res1)) {
32155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
32156 }
32157 arg1 = reinterpret_cast< wxWindow * >(argp1);
32158 }
32159 if (obj1) {
32160 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32161 if (!SWIG_IsOK(ecode2)) {
32162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
32163 }
32164 arg2 = static_cast< bool >(val2);
32165 }
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 result = (bool)wxSafeYield(arg1,arg2);
32169 wxPyEndAllowThreads(__tstate);
32170 if (PyErr_Occurred()) SWIG_fail;
32171 }
32172 {
32173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32174 }
32175 return resultobj;
32176 fail:
32177 return NULL;
32178 }
32179
32180
32181 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32182 PyObject *resultobj = 0;
32183
32184 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
32185 {
32186 PyThreadState* __tstate = wxPyBeginAllowThreads();
32187 wxWakeUpIdle();
32188 wxPyEndAllowThreads(__tstate);
32189 if (PyErr_Occurred()) SWIG_fail;
32190 }
32191 resultobj = SWIG_Py_Void();
32192 return resultobj;
32193 fail:
32194 return NULL;
32195 }
32196
32197
32198 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32199 PyObject *resultobj = 0;
32200 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
32201 wxEvent *arg2 = 0 ;
32202 void *argp1 = 0 ;
32203 int res1 = 0 ;
32204 void *argp2 = 0 ;
32205 int res2 = 0 ;
32206 PyObject * obj0 = 0 ;
32207 PyObject * obj1 = 0 ;
32208 char * kwnames[] = {
32209 (char *) "dest",(char *) "event", NULL
32210 };
32211
32212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
32213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
32214 if (!SWIG_IsOK(res1)) {
32215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
32216 }
32217 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
32218 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
32219 if (!SWIG_IsOK(res2)) {
32220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32221 }
32222 if (!argp2) {
32223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32224 }
32225 arg2 = reinterpret_cast< wxEvent * >(argp2);
32226 {
32227 PyThreadState* __tstate = wxPyBeginAllowThreads();
32228 wxPostEvent(arg1,*arg2);
32229 wxPyEndAllowThreads(__tstate);
32230 if (PyErr_Occurred()) SWIG_fail;
32231 }
32232 resultobj = SWIG_Py_Void();
32233 return resultobj;
32234 fail:
32235 return NULL;
32236 }
32237
32238
32239 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32240 PyObject *resultobj = 0;
32241
32242 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
32243 {
32244 PyThreadState* __tstate = wxPyBeginAllowThreads();
32245 wxApp_CleanUp();
32246 wxPyEndAllowThreads(__tstate);
32247 if (PyErr_Occurred()) SWIG_fail;
32248 }
32249 resultobj = SWIG_Py_Void();
32250 return resultobj;
32251 fail:
32252 return NULL;
32253 }
32254
32255
32256 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32257 PyObject *resultobj = 0;
32258 wxPyApp *result = 0 ;
32259
32260 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 result = (wxPyApp *)wxPyGetApp();
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 {
32268 resultobj = wxPyMake_wxObject(result, 0);
32269 }
32270 return resultobj;
32271 fail:
32272 return NULL;
32273 }
32274
32275
32276 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32277 PyObject *resultobj = 0;
32278 char *arg1 = (char *) 0 ;
32279 int res1 ;
32280 char *buf1 = 0 ;
32281 int alloc1 = 0 ;
32282 PyObject * obj0 = 0 ;
32283 char * kwnames[] = {
32284 (char *) "encoding", NULL
32285 };
32286
32287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
32288 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
32289 if (!SWIG_IsOK(res1)) {
32290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
32291 }
32292 arg1 = buf1;
32293 {
32294 PyThreadState* __tstate = wxPyBeginAllowThreads();
32295 wxSetDefaultPyEncoding((char const *)arg1);
32296 wxPyEndAllowThreads(__tstate);
32297 if (PyErr_Occurred()) SWIG_fail;
32298 }
32299 resultobj = SWIG_Py_Void();
32300 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32301 return resultobj;
32302 fail:
32303 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32304 return NULL;
32305 }
32306
32307
32308 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32309 PyObject *resultobj = 0;
32310 char *result = 0 ;
32311
32312 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
32313 {
32314 PyThreadState* __tstate = wxPyBeginAllowThreads();
32315 result = (char *)wxGetDefaultPyEncoding();
32316 wxPyEndAllowThreads(__tstate);
32317 if (PyErr_Occurred()) SWIG_fail;
32318 }
32319 resultobj = SWIG_FromCharPtr(result);
32320 return resultobj;
32321 fail:
32322 return NULL;
32323 }
32324
32325
32326 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32327 PyObject *resultobj = 0;
32328 wxEventLoop *result = 0 ;
32329
32330 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
32331 {
32332 PyThreadState* __tstate = wxPyBeginAllowThreads();
32333 result = (wxEventLoop *)new wxEventLoop();
32334 wxPyEndAllowThreads(__tstate);
32335 if (PyErr_Occurred()) SWIG_fail;
32336 }
32337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
32338 return resultobj;
32339 fail:
32340 return NULL;
32341 }
32342
32343
32344 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32345 PyObject *resultobj = 0;
32346 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32347 void *argp1 = 0 ;
32348 int res1 = 0 ;
32349 PyObject *swig_obj[1] ;
32350
32351 if (!args) SWIG_fail;
32352 swig_obj[0] = args;
32353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
32354 if (!SWIG_IsOK(res1)) {
32355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32356 }
32357 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 delete arg1;
32361
32362 wxPyEndAllowThreads(__tstate);
32363 if (PyErr_Occurred()) SWIG_fail;
32364 }
32365 resultobj = SWIG_Py_Void();
32366 return resultobj;
32367 fail:
32368 return NULL;
32369 }
32370
32371
32372 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32373 PyObject *resultobj = 0;
32374 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32375 int result;
32376 void *argp1 = 0 ;
32377 int res1 = 0 ;
32378 PyObject *swig_obj[1] ;
32379
32380 if (!args) SWIG_fail;
32381 swig_obj[0] = args;
32382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32383 if (!SWIG_IsOK(res1)) {
32384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32385 }
32386 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32387 {
32388 PyThreadState* __tstate = wxPyBeginAllowThreads();
32389 result = (int)(arg1)->Run();
32390 wxPyEndAllowThreads(__tstate);
32391 if (PyErr_Occurred()) SWIG_fail;
32392 }
32393 resultobj = SWIG_From_int(static_cast< int >(result));
32394 return resultobj;
32395 fail:
32396 return NULL;
32397 }
32398
32399
32400 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32401 PyObject *resultobj = 0;
32402 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32403 int arg2 = (int) 0 ;
32404 void *argp1 = 0 ;
32405 int res1 = 0 ;
32406 int val2 ;
32407 int ecode2 = 0 ;
32408 PyObject * obj0 = 0 ;
32409 PyObject * obj1 = 0 ;
32410 char * kwnames[] = {
32411 (char *) "self",(char *) "rc", NULL
32412 };
32413
32414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
32415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32416 if (!SWIG_IsOK(res1)) {
32417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32418 }
32419 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32420 if (obj1) {
32421 ecode2 = SWIG_AsVal_int(obj1, &val2);
32422 if (!SWIG_IsOK(ecode2)) {
32423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
32424 }
32425 arg2 = static_cast< int >(val2);
32426 }
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 (arg1)->Exit(arg2);
32430 wxPyEndAllowThreads(__tstate);
32431 if (PyErr_Occurred()) SWIG_fail;
32432 }
32433 resultobj = SWIG_Py_Void();
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32441 PyObject *resultobj = 0;
32442 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32443 bool result;
32444 void *argp1 = 0 ;
32445 int res1 = 0 ;
32446 PyObject *swig_obj[1] ;
32447
32448 if (!args) SWIG_fail;
32449 swig_obj[0] = args;
32450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32451 if (!SWIG_IsOK(res1)) {
32452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32453 }
32454 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 result = (bool)((wxEventLoop const *)arg1)->Pending();
32458 wxPyEndAllowThreads(__tstate);
32459 if (PyErr_Occurred()) SWIG_fail;
32460 }
32461 {
32462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32463 }
32464 return resultobj;
32465 fail:
32466 return NULL;
32467 }
32468
32469
32470 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32471 PyObject *resultobj = 0;
32472 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32473 bool result;
32474 void *argp1 = 0 ;
32475 int res1 = 0 ;
32476 PyObject *swig_obj[1] ;
32477
32478 if (!args) SWIG_fail;
32479 swig_obj[0] = args;
32480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32481 if (!SWIG_IsOK(res1)) {
32482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32483 }
32484 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32485 {
32486 PyThreadState* __tstate = wxPyBeginAllowThreads();
32487 result = (bool)(arg1)->Dispatch();
32488 wxPyEndAllowThreads(__tstate);
32489 if (PyErr_Occurred()) SWIG_fail;
32490 }
32491 {
32492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32493 }
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 PyObject *resultobj = 0;
32502 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32503 bool result;
32504 void *argp1 = 0 ;
32505 int res1 = 0 ;
32506 PyObject *swig_obj[1] ;
32507
32508 if (!args) SWIG_fail;
32509 swig_obj[0] = args;
32510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32513 }
32514 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 {
32522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32523 }
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32531 PyObject *resultobj = 0;
32532 wxEventLoop *result = 0 ;
32533
32534 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
32535 {
32536 PyThreadState* __tstate = wxPyBeginAllowThreads();
32537 result = (wxEventLoop *)wxEventLoop::GetActive();
32538 wxPyEndAllowThreads(__tstate);
32539 if (PyErr_Occurred()) SWIG_fail;
32540 }
32541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32542 return resultobj;
32543 fail:
32544 return NULL;
32545 }
32546
32547
32548 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32549 PyObject *resultobj = 0;
32550 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32551 void *argp1 = 0 ;
32552 int res1 = 0 ;
32553 PyObject * obj0 = 0 ;
32554 char * kwnames[] = {
32555 (char *) "loop", NULL
32556 };
32557
32558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32560 if (!SWIG_IsOK(res1)) {
32561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32562 }
32563 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32564 {
32565 PyThreadState* __tstate = wxPyBeginAllowThreads();
32566 wxEventLoop::SetActive(arg1);
32567 wxPyEndAllowThreads(__tstate);
32568 if (PyErr_Occurred()) SWIG_fail;
32569 }
32570 resultobj = SWIG_Py_Void();
32571 return resultobj;
32572 fail:
32573 return NULL;
32574 }
32575
32576
32577 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32578 PyObject *obj;
32579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32580 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32581 return SWIG_Py_Void();
32582 }
32583
32584 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32585 return SWIG_Python_InitShadowInstance(args);
32586 }
32587
32588 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32589 PyObject *resultobj = 0;
32590 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32591 wxEventLoopActivator *result = 0 ;
32592 void *argp1 = 0 ;
32593 int res1 = 0 ;
32594 PyObject * obj0 = 0 ;
32595 char * kwnames[] = {
32596 (char *) "evtLoop", NULL
32597 };
32598
32599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32601 if (!SWIG_IsOK(res1)) {
32602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32603 }
32604 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32605 {
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32608 wxPyEndAllowThreads(__tstate);
32609 if (PyErr_Occurred()) SWIG_fail;
32610 }
32611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32612 return resultobj;
32613 fail:
32614 return NULL;
32615 }
32616
32617
32618 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32619 PyObject *resultobj = 0;
32620 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32621 void *argp1 = 0 ;
32622 int res1 = 0 ;
32623 PyObject *swig_obj[1] ;
32624
32625 if (!args) SWIG_fail;
32626 swig_obj[0] = args;
32627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32628 if (!SWIG_IsOK(res1)) {
32629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32630 }
32631 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32632 {
32633 PyThreadState* __tstate = wxPyBeginAllowThreads();
32634 delete arg1;
32635
32636 wxPyEndAllowThreads(__tstate);
32637 if (PyErr_Occurred()) SWIG_fail;
32638 }
32639 resultobj = SWIG_Py_Void();
32640 return resultobj;
32641 fail:
32642 return NULL;
32643 }
32644
32645
32646 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32647 PyObject *obj;
32648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32649 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32650 return SWIG_Py_Void();
32651 }
32652
32653 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32654 return SWIG_Python_InitShadowInstance(args);
32655 }
32656
32657 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32658 PyObject *resultobj = 0;
32659 int arg1 = (int) 0 ;
32660 int arg2 = (int) 0 ;
32661 int arg3 = (int) 0 ;
32662 wxAcceleratorEntry *result = 0 ;
32663 int val1 ;
32664 int ecode1 = 0 ;
32665 int val2 ;
32666 int ecode2 = 0 ;
32667 int val3 ;
32668 int ecode3 = 0 ;
32669 PyObject * obj0 = 0 ;
32670 PyObject * obj1 = 0 ;
32671 PyObject * obj2 = 0 ;
32672 char * kwnames[] = {
32673 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32674 };
32675
32676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32677 if (obj0) {
32678 ecode1 = SWIG_AsVal_int(obj0, &val1);
32679 if (!SWIG_IsOK(ecode1)) {
32680 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32681 }
32682 arg1 = static_cast< int >(val1);
32683 }
32684 if (obj1) {
32685 ecode2 = SWIG_AsVal_int(obj1, &val2);
32686 if (!SWIG_IsOK(ecode2)) {
32687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32688 }
32689 arg2 = static_cast< int >(val2);
32690 }
32691 if (obj2) {
32692 ecode3 = SWIG_AsVal_int(obj2, &val3);
32693 if (!SWIG_IsOK(ecode3)) {
32694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32695 }
32696 arg3 = static_cast< int >(val3);
32697 }
32698 {
32699 PyThreadState* __tstate = wxPyBeginAllowThreads();
32700 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32701 wxPyEndAllowThreads(__tstate);
32702 if (PyErr_Occurred()) SWIG_fail;
32703 }
32704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32705 return resultobj;
32706 fail:
32707 return NULL;
32708 }
32709
32710
32711 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32712 PyObject *resultobj = 0;
32713 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32714 void *argp1 = 0 ;
32715 int res1 = 0 ;
32716 PyObject *swig_obj[1] ;
32717
32718 if (!args) SWIG_fail;
32719 swig_obj[0] = args;
32720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32721 if (!SWIG_IsOK(res1)) {
32722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32723 }
32724 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32725 {
32726 PyThreadState* __tstate = wxPyBeginAllowThreads();
32727 delete arg1;
32728
32729 wxPyEndAllowThreads(__tstate);
32730 if (PyErr_Occurred()) SWIG_fail;
32731 }
32732 resultobj = SWIG_Py_Void();
32733 return resultobj;
32734 fail:
32735 return NULL;
32736 }
32737
32738
32739 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32740 PyObject *resultobj = 0;
32741 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32742 int arg2 ;
32743 int arg3 ;
32744 int arg4 ;
32745 void *argp1 = 0 ;
32746 int res1 = 0 ;
32747 int val2 ;
32748 int ecode2 = 0 ;
32749 int val3 ;
32750 int ecode3 = 0 ;
32751 int val4 ;
32752 int ecode4 = 0 ;
32753 PyObject * obj0 = 0 ;
32754 PyObject * obj1 = 0 ;
32755 PyObject * obj2 = 0 ;
32756 PyObject * obj3 = 0 ;
32757 char * kwnames[] = {
32758 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32759 };
32760
32761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32763 if (!SWIG_IsOK(res1)) {
32764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32765 }
32766 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32767 ecode2 = SWIG_AsVal_int(obj1, &val2);
32768 if (!SWIG_IsOK(ecode2)) {
32769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32770 }
32771 arg2 = static_cast< int >(val2);
32772 ecode3 = SWIG_AsVal_int(obj2, &val3);
32773 if (!SWIG_IsOK(ecode3)) {
32774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32775 }
32776 arg3 = static_cast< int >(val3);
32777 ecode4 = SWIG_AsVal_int(obj3, &val4);
32778 if (!SWIG_IsOK(ecode4)) {
32779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32780 }
32781 arg4 = static_cast< int >(val4);
32782 {
32783 PyThreadState* __tstate = wxPyBeginAllowThreads();
32784 (arg1)->Set(arg2,arg3,arg4);
32785 wxPyEndAllowThreads(__tstate);
32786 if (PyErr_Occurred()) SWIG_fail;
32787 }
32788 resultobj = SWIG_Py_Void();
32789 return resultobj;
32790 fail:
32791 return NULL;
32792 }
32793
32794
32795 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32796 PyObject *resultobj = 0;
32797 wxString *arg1 = 0 ;
32798 wxAcceleratorEntry *result = 0 ;
32799 bool temp1 = false ;
32800 PyObject * obj0 = 0 ;
32801 char * kwnames[] = {
32802 (char *) "str", NULL
32803 };
32804
32805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32806 {
32807 arg1 = wxString_in_helper(obj0);
32808 if (arg1 == NULL) SWIG_fail;
32809 temp1 = true;
32810 }
32811 {
32812 PyThreadState* __tstate = wxPyBeginAllowThreads();
32813 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32814 wxPyEndAllowThreads(__tstate);
32815 if (PyErr_Occurred()) SWIG_fail;
32816 }
32817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32818 {
32819 if (temp1)
32820 delete arg1;
32821 }
32822 return resultobj;
32823 fail:
32824 {
32825 if (temp1)
32826 delete arg1;
32827 }
32828 return NULL;
32829 }
32830
32831
32832 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32833 PyObject *resultobj = 0;
32834 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32835 int result;
32836 void *argp1 = 0 ;
32837 int res1 = 0 ;
32838 PyObject *swig_obj[1] ;
32839
32840 if (!args) SWIG_fail;
32841 swig_obj[0] = args;
32842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32843 if (!SWIG_IsOK(res1)) {
32844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32845 }
32846 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32847 {
32848 PyThreadState* __tstate = wxPyBeginAllowThreads();
32849 result = (int)(arg1)->GetFlags();
32850 wxPyEndAllowThreads(__tstate);
32851 if (PyErr_Occurred()) SWIG_fail;
32852 }
32853 resultobj = SWIG_From_int(static_cast< int >(result));
32854 return resultobj;
32855 fail:
32856 return NULL;
32857 }
32858
32859
32860 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32861 PyObject *resultobj = 0;
32862 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32863 int result;
32864 void *argp1 = 0 ;
32865 int res1 = 0 ;
32866 PyObject *swig_obj[1] ;
32867
32868 if (!args) SWIG_fail;
32869 swig_obj[0] = args;
32870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32871 if (!SWIG_IsOK(res1)) {
32872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32873 }
32874 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32875 {
32876 PyThreadState* __tstate = wxPyBeginAllowThreads();
32877 result = (int)(arg1)->GetKeyCode();
32878 wxPyEndAllowThreads(__tstate);
32879 if (PyErr_Occurred()) SWIG_fail;
32880 }
32881 resultobj = SWIG_From_int(static_cast< int >(result));
32882 return resultobj;
32883 fail:
32884 return NULL;
32885 }
32886
32887
32888 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32889 PyObject *resultobj = 0;
32890 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32891 int result;
32892 void *argp1 = 0 ;
32893 int res1 = 0 ;
32894 PyObject *swig_obj[1] ;
32895
32896 if (!args) SWIG_fail;
32897 swig_obj[0] = args;
32898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32899 if (!SWIG_IsOK(res1)) {
32900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32901 }
32902 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32903 {
32904 PyThreadState* __tstate = wxPyBeginAllowThreads();
32905 result = (int)(arg1)->GetCommand();
32906 wxPyEndAllowThreads(__tstate);
32907 if (PyErr_Occurred()) SWIG_fail;
32908 }
32909 resultobj = SWIG_From_int(static_cast< int >(result));
32910 return resultobj;
32911 fail:
32912 return NULL;
32913 }
32914
32915
32916 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32917 PyObject *resultobj = 0;
32918 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32919 bool result;
32920 void *argp1 = 0 ;
32921 int res1 = 0 ;
32922 PyObject *swig_obj[1] ;
32923
32924 if (!args) SWIG_fail;
32925 swig_obj[0] = args;
32926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32927 if (!SWIG_IsOK(res1)) {
32928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32929 }
32930 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32931 {
32932 PyThreadState* __tstate = wxPyBeginAllowThreads();
32933 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32934 wxPyEndAllowThreads(__tstate);
32935 if (PyErr_Occurred()) SWIG_fail;
32936 }
32937 {
32938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32939 }
32940 return resultobj;
32941 fail:
32942 return NULL;
32943 }
32944
32945
32946 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32947 PyObject *resultobj = 0;
32948 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32949 wxString result;
32950 void *argp1 = 0 ;
32951 int res1 = 0 ;
32952 PyObject *swig_obj[1] ;
32953
32954 if (!args) SWIG_fail;
32955 swig_obj[0] = args;
32956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32957 if (!SWIG_IsOK(res1)) {
32958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32959 }
32960 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32961 {
32962 PyThreadState* __tstate = wxPyBeginAllowThreads();
32963 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32964 wxPyEndAllowThreads(__tstate);
32965 if (PyErr_Occurred()) SWIG_fail;
32966 }
32967 {
32968 #if wxUSE_UNICODE
32969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32970 #else
32971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32972 #endif
32973 }
32974 return resultobj;
32975 fail:
32976 return NULL;
32977 }
32978
32979
32980 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32981 PyObject *resultobj = 0;
32982 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32983 wxString *arg2 = 0 ;
32984 bool result;
32985 void *argp1 = 0 ;
32986 int res1 = 0 ;
32987 bool temp2 = false ;
32988 PyObject * obj0 = 0 ;
32989 PyObject * obj1 = 0 ;
32990 char * kwnames[] = {
32991 (char *) "self",(char *) "str", NULL
32992 };
32993
32994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32996 if (!SWIG_IsOK(res1)) {
32997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32998 }
32999 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
33000 {
33001 arg2 = wxString_in_helper(obj1);
33002 if (arg2 == NULL) SWIG_fail;
33003 temp2 = true;
33004 }
33005 {
33006 PyThreadState* __tstate = wxPyBeginAllowThreads();
33007 result = (bool)(arg1)->FromString((wxString const &)*arg2);
33008 wxPyEndAllowThreads(__tstate);
33009 if (PyErr_Occurred()) SWIG_fail;
33010 }
33011 {
33012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33013 }
33014 {
33015 if (temp2)
33016 delete arg2;
33017 }
33018 return resultobj;
33019 fail:
33020 {
33021 if (temp2)
33022 delete arg2;
33023 }
33024 return NULL;
33025 }
33026
33027
33028 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33029 PyObject *obj;
33030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33031 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
33032 return SWIG_Py_Void();
33033 }
33034
33035 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33036 return SWIG_Python_InitShadowInstance(args);
33037 }
33038
33039 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33040 PyObject *resultobj = 0;
33041 int arg1 ;
33042 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
33043 wxAcceleratorTable *result = 0 ;
33044 PyObject * obj0 = 0 ;
33045 char * kwnames[] = {
33046 (char *) "n", NULL
33047 };
33048
33049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
33050 {
33051 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
33052 if (arg2) arg1 = PyList_Size(obj0);
33053 else arg1 = 0;
33054 }
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
33062 return resultobj;
33063 fail:
33064 return NULL;
33065 }
33066
33067
33068 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33069 PyObject *resultobj = 0;
33070 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33071 void *argp1 = 0 ;
33072 int res1 = 0 ;
33073 PyObject *swig_obj[1] ;
33074
33075 if (!args) SWIG_fail;
33076 swig_obj[0] = args;
33077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
33078 if (!SWIG_IsOK(res1)) {
33079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
33080 }
33081 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33082 {
33083 PyThreadState* __tstate = wxPyBeginAllowThreads();
33084 delete arg1;
33085
33086 wxPyEndAllowThreads(__tstate);
33087 if (PyErr_Occurred()) SWIG_fail;
33088 }
33089 resultobj = SWIG_Py_Void();
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33097 PyObject *resultobj = 0;
33098 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33099 bool result;
33100 void *argp1 = 0 ;
33101 int res1 = 0 ;
33102 PyObject *swig_obj[1] ;
33103
33104 if (!args) SWIG_fail;
33105 swig_obj[0] = args;
33106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33107 if (!SWIG_IsOK(res1)) {
33108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
33109 }
33110 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33111 {
33112 PyThreadState* __tstate = wxPyBeginAllowThreads();
33113 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
33114 wxPyEndAllowThreads(__tstate);
33115 if (PyErr_Occurred()) SWIG_fail;
33116 }
33117 {
33118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33119 }
33120 return resultobj;
33121 fail:
33122 return NULL;
33123 }
33124
33125
33126 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33127 PyObject *obj;
33128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33129 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
33130 return SWIG_Py_Void();
33131 }
33132
33133 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33134 return SWIG_Python_InitShadowInstance(args);
33135 }
33136
33137 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
33138 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
33139 return 1;
33140 }
33141
33142
33143 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
33144 PyObject *pyobj = 0;
33145
33146 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
33147 return pyobj;
33148 }
33149
33150
33151 SWIGINTERN int PanelNameStr_set(PyObject *) {
33152 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
33153 return 1;
33154 }
33155
33156
33157 SWIGINTERN PyObject *PanelNameStr_get(void) {
33158 PyObject *pyobj = 0;
33159
33160 {
33161 #if wxUSE_UNICODE
33162 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33163 #else
33164 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33165 #endif
33166 }
33167 return pyobj;
33168 }
33169
33170
33171 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33172 PyObject *resultobj = 0;
33173 wxVisualAttributes *result = 0 ;
33174
33175 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
33176 {
33177 PyThreadState* __tstate = wxPyBeginAllowThreads();
33178 result = (wxVisualAttributes *)new_wxVisualAttributes();
33179 wxPyEndAllowThreads(__tstate);
33180 if (PyErr_Occurred()) SWIG_fail;
33181 }
33182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
33183 return resultobj;
33184 fail:
33185 return NULL;
33186 }
33187
33188
33189 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33190 PyObject *resultobj = 0;
33191 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33192 void *argp1 = 0 ;
33193 int res1 = 0 ;
33194 PyObject *swig_obj[1] ;
33195
33196 if (!args) SWIG_fail;
33197 swig_obj[0] = args;
33198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
33199 if (!SWIG_IsOK(res1)) {
33200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33201 }
33202 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33203 {
33204 PyThreadState* __tstate = wxPyBeginAllowThreads();
33205 delete_wxVisualAttributes(arg1);
33206
33207 wxPyEndAllowThreads(__tstate);
33208 if (PyErr_Occurred()) SWIG_fail;
33209 }
33210 resultobj = SWIG_Py_Void();
33211 return resultobj;
33212 fail:
33213 return NULL;
33214 }
33215
33216
33217 SWIGINTERN PyObject *_wrap_VisualAttributes__get_font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33218 PyObject *resultobj = 0;
33219 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33220 wxFont result;
33221 void *argp1 = 0 ;
33222 int res1 = 0 ;
33223 PyObject *swig_obj[1] ;
33224
33225 if (!args) SWIG_fail;
33226 swig_obj[0] = args;
33227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33228 if (!SWIG_IsOK(res1)) {
33229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_font" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33230 }
33231 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 result = wxVisualAttributes__get_font(arg1);
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
33239 return resultobj;
33240 fail:
33241 return NULL;
33242 }
33243
33244
33245 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colFg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33246 PyObject *resultobj = 0;
33247 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33248 wxColour result;
33249 void *argp1 = 0 ;
33250 int res1 = 0 ;
33251 PyObject *swig_obj[1] ;
33252
33253 if (!args) SWIG_fail;
33254 swig_obj[0] = args;
33255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33256 if (!SWIG_IsOK(res1)) {
33257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colFg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33258 }
33259 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33260 {
33261 PyThreadState* __tstate = wxPyBeginAllowThreads();
33262 result = wxVisualAttributes__get_colFg(arg1);
33263 wxPyEndAllowThreads(__tstate);
33264 if (PyErr_Occurred()) SWIG_fail;
33265 }
33266 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33267 return resultobj;
33268 fail:
33269 return NULL;
33270 }
33271
33272
33273 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colBg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33274 PyObject *resultobj = 0;
33275 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33276 wxColour result;
33277 void *argp1 = 0 ;
33278 int res1 = 0 ;
33279 PyObject *swig_obj[1] ;
33280
33281 if (!args) SWIG_fail;
33282 swig_obj[0] = args;
33283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33284 if (!SWIG_IsOK(res1)) {
33285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colBg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33286 }
33287 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33288 {
33289 PyThreadState* __tstate = wxPyBeginAllowThreads();
33290 result = wxVisualAttributes__get_colBg(arg1);
33291 wxPyEndAllowThreads(__tstate);
33292 if (PyErr_Occurred()) SWIG_fail;
33293 }
33294 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33295 return resultobj;
33296 fail:
33297 return NULL;
33298 }
33299
33300
33301 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33302 PyObject *obj;
33303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33304 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
33305 return SWIG_Py_Void();
33306 }
33307
33308 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33309 return SWIG_Python_InitShadowInstance(args);
33310 }
33311
33312 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33313 PyObject *resultobj = 0;
33314 wxWindow *arg1 = (wxWindow *) 0 ;
33315 int arg2 = (int) (int)-1 ;
33316 wxPoint const &arg3_defvalue = wxDefaultPosition ;
33317 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
33318 wxSize const &arg4_defvalue = wxDefaultSize ;
33319 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
33320 long arg5 = (long) 0 ;
33321 wxString const &arg6_defvalue = wxPyPanelNameStr ;
33322 wxString *arg6 = (wxString *) &arg6_defvalue ;
33323 wxWindow *result = 0 ;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 int val2 ;
33327 int ecode2 = 0 ;
33328 wxPoint temp3 ;
33329 wxSize temp4 ;
33330 long val5 ;
33331 int ecode5 = 0 ;
33332 bool temp6 = false ;
33333 PyObject * obj0 = 0 ;
33334 PyObject * obj1 = 0 ;
33335 PyObject * obj2 = 0 ;
33336 PyObject * obj3 = 0 ;
33337 PyObject * obj4 = 0 ;
33338 PyObject * obj5 = 0 ;
33339 char * kwnames[] = {
33340 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33341 };
33342
33343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33345 if (!SWIG_IsOK(res1)) {
33346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
33347 }
33348 arg1 = reinterpret_cast< wxWindow * >(argp1);
33349 if (obj1) {
33350 ecode2 = SWIG_AsVal_int(obj1, &val2);
33351 if (!SWIG_IsOK(ecode2)) {
33352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
33353 }
33354 arg2 = static_cast< int >(val2);
33355 }
33356 if (obj2) {
33357 {
33358 arg3 = &temp3;
33359 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
33360 }
33361 }
33362 if (obj3) {
33363 {
33364 arg4 = &temp4;
33365 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
33366 }
33367 }
33368 if (obj4) {
33369 ecode5 = SWIG_AsVal_long(obj4, &val5);
33370 if (!SWIG_IsOK(ecode5)) {
33371 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
33372 }
33373 arg5 = static_cast< long >(val5);
33374 }
33375 if (obj5) {
33376 {
33377 arg6 = wxString_in_helper(obj5);
33378 if (arg6 == NULL) SWIG_fail;
33379 temp6 = true;
33380 }
33381 }
33382 {
33383 if (!wxPyCheckForApp()) SWIG_fail;
33384 PyThreadState* __tstate = wxPyBeginAllowThreads();
33385 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
33386 wxPyEndAllowThreads(__tstate);
33387 if (PyErr_Occurred()) SWIG_fail;
33388 }
33389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
33390 {
33391 if (temp6)
33392 delete arg6;
33393 }
33394 return resultobj;
33395 fail:
33396 {
33397 if (temp6)
33398 delete arg6;
33399 }
33400 return NULL;
33401 }
33402
33403
33404 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33405 PyObject *resultobj = 0;
33406 wxWindow *result = 0 ;
33407
33408 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
33409 {
33410 if (!wxPyCheckForApp()) SWIG_fail;
33411 PyThreadState* __tstate = wxPyBeginAllowThreads();
33412 result = (wxWindow *)new wxWindow();
33413 wxPyEndAllowThreads(__tstate);
33414 if (PyErr_Occurred()) SWIG_fail;
33415 }
33416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
33417 return resultobj;
33418 fail:
33419 return NULL;
33420 }
33421
33422
33423 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33424 PyObject *resultobj = 0;
33425 wxWindow *arg1 = (wxWindow *) 0 ;
33426 wxWindow *arg2 = (wxWindow *) 0 ;
33427 int arg3 = (int) (int)-1 ;
33428 wxPoint const &arg4_defvalue = wxDefaultPosition ;
33429 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
33430 wxSize const &arg5_defvalue = wxDefaultSize ;
33431 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
33432 long arg6 = (long) 0 ;
33433 wxString const &arg7_defvalue = wxPyPanelNameStr ;
33434 wxString *arg7 = (wxString *) &arg7_defvalue ;
33435 bool result;
33436 void *argp1 = 0 ;
33437 int res1 = 0 ;
33438 void *argp2 = 0 ;
33439 int res2 = 0 ;
33440 int val3 ;
33441 int ecode3 = 0 ;
33442 wxPoint temp4 ;
33443 wxSize temp5 ;
33444 long val6 ;
33445 int ecode6 = 0 ;
33446 bool temp7 = false ;
33447 PyObject * obj0 = 0 ;
33448 PyObject * obj1 = 0 ;
33449 PyObject * obj2 = 0 ;
33450 PyObject * obj3 = 0 ;
33451 PyObject * obj4 = 0 ;
33452 PyObject * obj5 = 0 ;
33453 PyObject * obj6 = 0 ;
33454 char * kwnames[] = {
33455 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33456 };
33457
33458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33460 if (!SWIG_IsOK(res1)) {
33461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33462 }
33463 arg1 = reinterpret_cast< wxWindow * >(argp1);
33464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33465 if (!SWIG_IsOK(res2)) {
33466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33467 }
33468 arg2 = reinterpret_cast< wxWindow * >(argp2);
33469 if (obj2) {
33470 ecode3 = SWIG_AsVal_int(obj2, &val3);
33471 if (!SWIG_IsOK(ecode3)) {
33472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33473 }
33474 arg3 = static_cast< int >(val3);
33475 }
33476 if (obj3) {
33477 {
33478 arg4 = &temp4;
33479 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33480 }
33481 }
33482 if (obj4) {
33483 {
33484 arg5 = &temp5;
33485 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33486 }
33487 }
33488 if (obj5) {
33489 ecode6 = SWIG_AsVal_long(obj5, &val6);
33490 if (!SWIG_IsOK(ecode6)) {
33491 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33492 }
33493 arg6 = static_cast< long >(val6);
33494 }
33495 if (obj6) {
33496 {
33497 arg7 = wxString_in_helper(obj6);
33498 if (arg7 == NULL) SWIG_fail;
33499 temp7 = true;
33500 }
33501 }
33502 {
33503 PyThreadState* __tstate = wxPyBeginAllowThreads();
33504 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33505 wxPyEndAllowThreads(__tstate);
33506 if (PyErr_Occurred()) SWIG_fail;
33507 }
33508 {
33509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33510 }
33511 {
33512 if (temp7)
33513 delete arg7;
33514 }
33515 return resultobj;
33516 fail:
33517 {
33518 if (temp7)
33519 delete arg7;
33520 }
33521 return NULL;
33522 }
33523
33524
33525 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33526 PyObject *resultobj = 0;
33527 wxWindow *arg1 = (wxWindow *) 0 ;
33528 bool arg2 = (bool) false ;
33529 bool result;
33530 void *argp1 = 0 ;
33531 int res1 = 0 ;
33532 bool val2 ;
33533 int ecode2 = 0 ;
33534 PyObject * obj0 = 0 ;
33535 PyObject * obj1 = 0 ;
33536 char * kwnames[] = {
33537 (char *) "self",(char *) "force", NULL
33538 };
33539
33540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33542 if (!SWIG_IsOK(res1)) {
33543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33544 }
33545 arg1 = reinterpret_cast< wxWindow * >(argp1);
33546 if (obj1) {
33547 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33548 if (!SWIG_IsOK(ecode2)) {
33549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33550 }
33551 arg2 = static_cast< bool >(val2);
33552 }
33553 {
33554 PyThreadState* __tstate = wxPyBeginAllowThreads();
33555 result = (bool)(arg1)->Close(arg2);
33556 wxPyEndAllowThreads(__tstate);
33557 if (PyErr_Occurred()) SWIG_fail;
33558 }
33559 {
33560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33561 }
33562 return resultobj;
33563 fail:
33564 return NULL;
33565 }
33566
33567
33568 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33569 PyObject *resultobj = 0;
33570 wxWindow *arg1 = (wxWindow *) 0 ;
33571 bool result;
33572 void *argp1 = 0 ;
33573 int res1 = 0 ;
33574 PyObject *swig_obj[1] ;
33575
33576 if (!args) SWIG_fail;
33577 swig_obj[0] = args;
33578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33579 if (!SWIG_IsOK(res1)) {
33580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33581 }
33582 arg1 = reinterpret_cast< wxWindow * >(argp1);
33583 {
33584 PyThreadState* __tstate = wxPyBeginAllowThreads();
33585 result = (bool)(arg1)->Destroy();
33586 wxPyEndAllowThreads(__tstate);
33587 if (PyErr_Occurred()) SWIG_fail;
33588 }
33589 {
33590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33591 }
33592 return resultobj;
33593 fail:
33594 return NULL;
33595 }
33596
33597
33598 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33599 PyObject *resultobj = 0;
33600 wxWindow *arg1 = (wxWindow *) 0 ;
33601 bool result;
33602 void *argp1 = 0 ;
33603 int res1 = 0 ;
33604 PyObject *swig_obj[1] ;
33605
33606 if (!args) SWIG_fail;
33607 swig_obj[0] = args;
33608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33609 if (!SWIG_IsOK(res1)) {
33610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33611 }
33612 arg1 = reinterpret_cast< wxWindow * >(argp1);
33613 {
33614 PyThreadState* __tstate = wxPyBeginAllowThreads();
33615 result = (bool)(arg1)->DestroyChildren();
33616 wxPyEndAllowThreads(__tstate);
33617 if (PyErr_Occurred()) SWIG_fail;
33618 }
33619 {
33620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33621 }
33622 return resultobj;
33623 fail:
33624 return NULL;
33625 }
33626
33627
33628 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33629 PyObject *resultobj = 0;
33630 wxWindow *arg1 = (wxWindow *) 0 ;
33631 bool result;
33632 void *argp1 = 0 ;
33633 int res1 = 0 ;
33634 PyObject *swig_obj[1] ;
33635
33636 if (!args) SWIG_fail;
33637 swig_obj[0] = args;
33638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33639 if (!SWIG_IsOK(res1)) {
33640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33641 }
33642 arg1 = reinterpret_cast< wxWindow * >(argp1);
33643 {
33644 PyThreadState* __tstate = wxPyBeginAllowThreads();
33645 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 {
33650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33651 }
33652 return resultobj;
33653 fail:
33654 return NULL;
33655 }
33656
33657
33658 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33659 PyObject *resultobj = 0;
33660 wxWindow *arg1 = (wxWindow *) 0 ;
33661 wxString *arg2 = 0 ;
33662 void *argp1 = 0 ;
33663 int res1 = 0 ;
33664 bool temp2 = false ;
33665 PyObject * obj0 = 0 ;
33666 PyObject * obj1 = 0 ;
33667 char * kwnames[] = {
33668 (char *) "self",(char *) "label", NULL
33669 };
33670
33671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33673 if (!SWIG_IsOK(res1)) {
33674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33675 }
33676 arg1 = reinterpret_cast< wxWindow * >(argp1);
33677 {
33678 arg2 = wxString_in_helper(obj1);
33679 if (arg2 == NULL) SWIG_fail;
33680 temp2 = true;
33681 }
33682 {
33683 PyThreadState* __tstate = wxPyBeginAllowThreads();
33684 (arg1)->SetLabel((wxString const &)*arg2);
33685 wxPyEndAllowThreads(__tstate);
33686 if (PyErr_Occurred()) SWIG_fail;
33687 }
33688 resultobj = SWIG_Py_Void();
33689 {
33690 if (temp2)
33691 delete arg2;
33692 }
33693 return resultobj;
33694 fail:
33695 {
33696 if (temp2)
33697 delete arg2;
33698 }
33699 return NULL;
33700 }
33701
33702
33703 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33704 PyObject *resultobj = 0;
33705 wxWindow *arg1 = (wxWindow *) 0 ;
33706 wxString result;
33707 void *argp1 = 0 ;
33708 int res1 = 0 ;
33709 PyObject *swig_obj[1] ;
33710
33711 if (!args) SWIG_fail;
33712 swig_obj[0] = args;
33713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33714 if (!SWIG_IsOK(res1)) {
33715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33716 }
33717 arg1 = reinterpret_cast< wxWindow * >(argp1);
33718 {
33719 PyThreadState* __tstate = wxPyBeginAllowThreads();
33720 result = ((wxWindow const *)arg1)->GetLabel();
33721 wxPyEndAllowThreads(__tstate);
33722 if (PyErr_Occurred()) SWIG_fail;
33723 }
33724 {
33725 #if wxUSE_UNICODE
33726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33727 #else
33728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33729 #endif
33730 }
33731 return resultobj;
33732 fail:
33733 return NULL;
33734 }
33735
33736
33737 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33738 PyObject *resultobj = 0;
33739 wxWindow *arg1 = (wxWindow *) 0 ;
33740 wxString *arg2 = 0 ;
33741 void *argp1 = 0 ;
33742 int res1 = 0 ;
33743 bool temp2 = false ;
33744 PyObject * obj0 = 0 ;
33745 PyObject * obj1 = 0 ;
33746 char * kwnames[] = {
33747 (char *) "self",(char *) "name", NULL
33748 };
33749
33750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33752 if (!SWIG_IsOK(res1)) {
33753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33754 }
33755 arg1 = reinterpret_cast< wxWindow * >(argp1);
33756 {
33757 arg2 = wxString_in_helper(obj1);
33758 if (arg2 == NULL) SWIG_fail;
33759 temp2 = true;
33760 }
33761 {
33762 PyThreadState* __tstate = wxPyBeginAllowThreads();
33763 (arg1)->SetName((wxString const &)*arg2);
33764 wxPyEndAllowThreads(__tstate);
33765 if (PyErr_Occurred()) SWIG_fail;
33766 }
33767 resultobj = SWIG_Py_Void();
33768 {
33769 if (temp2)
33770 delete arg2;
33771 }
33772 return resultobj;
33773 fail:
33774 {
33775 if (temp2)
33776 delete arg2;
33777 }
33778 return NULL;
33779 }
33780
33781
33782 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33783 PyObject *resultobj = 0;
33784 wxWindow *arg1 = (wxWindow *) 0 ;
33785 wxString result;
33786 void *argp1 = 0 ;
33787 int res1 = 0 ;
33788 PyObject *swig_obj[1] ;
33789
33790 if (!args) SWIG_fail;
33791 swig_obj[0] = args;
33792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33793 if (!SWIG_IsOK(res1)) {
33794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33795 }
33796 arg1 = reinterpret_cast< wxWindow * >(argp1);
33797 {
33798 PyThreadState* __tstate = wxPyBeginAllowThreads();
33799 result = ((wxWindow const *)arg1)->GetName();
33800 wxPyEndAllowThreads(__tstate);
33801 if (PyErr_Occurred()) SWIG_fail;
33802 }
33803 {
33804 #if wxUSE_UNICODE
33805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33806 #else
33807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33808 #endif
33809 }
33810 return resultobj;
33811 fail:
33812 return NULL;
33813 }
33814
33815
33816 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj = 0;
33818 wxWindow *arg1 = (wxWindow *) 0 ;
33819 wxWindowVariant arg2 ;
33820 void *argp1 = 0 ;
33821 int res1 = 0 ;
33822 int val2 ;
33823 int ecode2 = 0 ;
33824 PyObject * obj0 = 0 ;
33825 PyObject * obj1 = 0 ;
33826 char * kwnames[] = {
33827 (char *) "self",(char *) "variant", NULL
33828 };
33829
33830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33832 if (!SWIG_IsOK(res1)) {
33833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33834 }
33835 arg1 = reinterpret_cast< wxWindow * >(argp1);
33836 ecode2 = SWIG_AsVal_int(obj1, &val2);
33837 if (!SWIG_IsOK(ecode2)) {
33838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33839 }
33840 arg2 = static_cast< wxWindowVariant >(val2);
33841 {
33842 PyThreadState* __tstate = wxPyBeginAllowThreads();
33843 (arg1)->SetWindowVariant(arg2);
33844 wxPyEndAllowThreads(__tstate);
33845 if (PyErr_Occurred()) SWIG_fail;
33846 }
33847 resultobj = SWIG_Py_Void();
33848 return resultobj;
33849 fail:
33850 return NULL;
33851 }
33852
33853
33854 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33855 PyObject *resultobj = 0;
33856 wxWindow *arg1 = (wxWindow *) 0 ;
33857 wxWindowVariant result;
33858 void *argp1 = 0 ;
33859 int res1 = 0 ;
33860 PyObject *swig_obj[1] ;
33861
33862 if (!args) SWIG_fail;
33863 swig_obj[0] = args;
33864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33865 if (!SWIG_IsOK(res1)) {
33866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33867 }
33868 arg1 = reinterpret_cast< wxWindow * >(argp1);
33869 {
33870 PyThreadState* __tstate = wxPyBeginAllowThreads();
33871 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33872 wxPyEndAllowThreads(__tstate);
33873 if (PyErr_Occurred()) SWIG_fail;
33874 }
33875 resultobj = SWIG_From_int(static_cast< int >(result));
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj = 0;
33884 wxWindow *arg1 = (wxWindow *) 0 ;
33885 int arg2 ;
33886 void *argp1 = 0 ;
33887 int res1 = 0 ;
33888 int val2 ;
33889 int ecode2 = 0 ;
33890 PyObject * obj0 = 0 ;
33891 PyObject * obj1 = 0 ;
33892 char * kwnames[] = {
33893 (char *) "self",(char *) "winid", NULL
33894 };
33895
33896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33898 if (!SWIG_IsOK(res1)) {
33899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33900 }
33901 arg1 = reinterpret_cast< wxWindow * >(argp1);
33902 ecode2 = SWIG_AsVal_int(obj1, &val2);
33903 if (!SWIG_IsOK(ecode2)) {
33904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33905 }
33906 arg2 = static_cast< int >(val2);
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 (arg1)->SetId(arg2);
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 resultobj = SWIG_Py_Void();
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33921 PyObject *resultobj = 0;
33922 wxWindow *arg1 = (wxWindow *) 0 ;
33923 int result;
33924 void *argp1 = 0 ;
33925 int res1 = 0 ;
33926 PyObject *swig_obj[1] ;
33927
33928 if (!args) SWIG_fail;
33929 swig_obj[0] = args;
33930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33931 if (!SWIG_IsOK(res1)) {
33932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33933 }
33934 arg1 = reinterpret_cast< wxWindow * >(argp1);
33935 {
33936 PyThreadState* __tstate = wxPyBeginAllowThreads();
33937 result = (int)((wxWindow const *)arg1)->GetId();
33938 wxPyEndAllowThreads(__tstate);
33939 if (PyErr_Occurred()) SWIG_fail;
33940 }
33941 resultobj = SWIG_From_int(static_cast< int >(result));
33942 return resultobj;
33943 fail:
33944 return NULL;
33945 }
33946
33947
33948 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33949 PyObject *resultobj = 0;
33950 int result;
33951
33952 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33953 {
33954 PyThreadState* __tstate = wxPyBeginAllowThreads();
33955 result = (int)wxWindow::NewControlId();
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 resultobj = SWIG_From_int(static_cast< int >(result));
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33967 PyObject *resultobj = 0;
33968 int arg1 ;
33969 int result;
33970 int val1 ;
33971 int ecode1 = 0 ;
33972 PyObject * obj0 = 0 ;
33973 char * kwnames[] = {
33974 (char *) "winid", NULL
33975 };
33976
33977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33978 ecode1 = SWIG_AsVal_int(obj0, &val1);
33979 if (!SWIG_IsOK(ecode1)) {
33980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33981 }
33982 arg1 = static_cast< int >(val1);
33983 {
33984 PyThreadState* __tstate = wxPyBeginAllowThreads();
33985 result = (int)wxWindow::NextControlId(arg1);
33986 wxPyEndAllowThreads(__tstate);
33987 if (PyErr_Occurred()) SWIG_fail;
33988 }
33989 resultobj = SWIG_From_int(static_cast< int >(result));
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33997 PyObject *resultobj = 0;
33998 int arg1 ;
33999 int result;
34000 int val1 ;
34001 int ecode1 = 0 ;
34002 PyObject * obj0 = 0 ;
34003 char * kwnames[] = {
34004 (char *) "winid", NULL
34005 };
34006
34007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
34008 ecode1 = SWIG_AsVal_int(obj0, &val1);
34009 if (!SWIG_IsOK(ecode1)) {
34010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
34011 }
34012 arg1 = static_cast< int >(val1);
34013 {
34014 PyThreadState* __tstate = wxPyBeginAllowThreads();
34015 result = (int)wxWindow::PrevControlId(arg1);
34016 wxPyEndAllowThreads(__tstate);
34017 if (PyErr_Occurred()) SWIG_fail;
34018 }
34019 resultobj = SWIG_From_int(static_cast< int >(result));
34020 return resultobj;
34021 fail:
34022 return NULL;
34023 }
34024
34025
34026 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34027 PyObject *resultobj = 0;
34028 wxWindow *arg1 = (wxWindow *) 0 ;
34029 wxLayoutDirection result;
34030 void *argp1 = 0 ;
34031 int res1 = 0 ;
34032 PyObject *swig_obj[1] ;
34033
34034 if (!args) SWIG_fail;
34035 swig_obj[0] = args;
34036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34037 if (!SWIG_IsOK(res1)) {
34038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34039 }
34040 arg1 = reinterpret_cast< wxWindow * >(argp1);
34041 {
34042 PyThreadState* __tstate = wxPyBeginAllowThreads();
34043 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
34044 wxPyEndAllowThreads(__tstate);
34045 if (PyErr_Occurred()) SWIG_fail;
34046 }
34047 resultobj = SWIG_From_int(static_cast< int >(result));
34048 return resultobj;
34049 fail:
34050 return NULL;
34051 }
34052
34053
34054 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34055 PyObject *resultobj = 0;
34056 wxWindow *arg1 = (wxWindow *) 0 ;
34057 wxLayoutDirection arg2 ;
34058 void *argp1 = 0 ;
34059 int res1 = 0 ;
34060 int val2 ;
34061 int ecode2 = 0 ;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 char * kwnames[] = {
34065 (char *) "self",(char *) "dir", NULL
34066 };
34067
34068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
34069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 ecode2 = SWIG_AsVal_int(obj1, &val2);
34075 if (!SWIG_IsOK(ecode2)) {
34076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
34077 }
34078 arg2 = static_cast< wxLayoutDirection >(val2);
34079 {
34080 PyThreadState* __tstate = wxPyBeginAllowThreads();
34081 (arg1)->SetLayoutDirection(arg2);
34082 wxPyEndAllowThreads(__tstate);
34083 if (PyErr_Occurred()) SWIG_fail;
34084 }
34085 resultobj = SWIG_Py_Void();
34086 return resultobj;
34087 fail:
34088 return NULL;
34089 }
34090
34091
34092 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34093 PyObject *resultobj = 0;
34094 wxWindow *arg1 = (wxWindow *) 0 ;
34095 int arg2 ;
34096 int arg3 ;
34097 int arg4 ;
34098 int result;
34099 void *argp1 = 0 ;
34100 int res1 = 0 ;
34101 int val2 ;
34102 int ecode2 = 0 ;
34103 int val3 ;
34104 int ecode3 = 0 ;
34105 int val4 ;
34106 int ecode4 = 0 ;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 PyObject * obj2 = 0 ;
34110 PyObject * obj3 = 0 ;
34111 char * kwnames[] = {
34112 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
34113 };
34114
34115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34117 if (!SWIG_IsOK(res1)) {
34118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34119 }
34120 arg1 = reinterpret_cast< wxWindow * >(argp1);
34121 ecode2 = SWIG_AsVal_int(obj1, &val2);
34122 if (!SWIG_IsOK(ecode2)) {
34123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
34124 }
34125 arg2 = static_cast< int >(val2);
34126 ecode3 = SWIG_AsVal_int(obj2, &val3);
34127 if (!SWIG_IsOK(ecode3)) {
34128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
34129 }
34130 arg3 = static_cast< int >(val3);
34131 ecode4 = SWIG_AsVal_int(obj3, &val4);
34132 if (!SWIG_IsOK(ecode4)) {
34133 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
34134 }
34135 arg4 = static_cast< int >(val4);
34136 {
34137 PyThreadState* __tstate = wxPyBeginAllowThreads();
34138 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
34139 wxPyEndAllowThreads(__tstate);
34140 if (PyErr_Occurred()) SWIG_fail;
34141 }
34142 resultobj = SWIG_From_int(static_cast< int >(result));
34143 return resultobj;
34144 fail:
34145 return NULL;
34146 }
34147
34148
34149 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34150 PyObject *resultobj = 0;
34151 wxWindow *arg1 = (wxWindow *) 0 ;
34152 wxSize *arg2 = 0 ;
34153 void *argp1 = 0 ;
34154 int res1 = 0 ;
34155 wxSize temp2 ;
34156 PyObject * obj0 = 0 ;
34157 PyObject * obj1 = 0 ;
34158 char * kwnames[] = {
34159 (char *) "self",(char *) "size", NULL
34160 };
34161
34162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
34163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34164 if (!SWIG_IsOK(res1)) {
34165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34166 }
34167 arg1 = reinterpret_cast< wxWindow * >(argp1);
34168 {
34169 arg2 = &temp2;
34170 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34171 }
34172 {
34173 PyThreadState* __tstate = wxPyBeginAllowThreads();
34174 (arg1)->SetSize((wxSize const &)*arg2);
34175 wxPyEndAllowThreads(__tstate);
34176 if (PyErr_Occurred()) SWIG_fail;
34177 }
34178 resultobj = SWIG_Py_Void();
34179 return resultobj;
34180 fail:
34181 return NULL;
34182 }
34183
34184
34185 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34186 PyObject *resultobj = 0;
34187 wxWindow *arg1 = (wxWindow *) 0 ;
34188 int arg2 ;
34189 int arg3 ;
34190 int arg4 ;
34191 int arg5 ;
34192 int arg6 = (int) wxSIZE_AUTO ;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 int val2 ;
34196 int ecode2 = 0 ;
34197 int val3 ;
34198 int ecode3 = 0 ;
34199 int val4 ;
34200 int ecode4 = 0 ;
34201 int val5 ;
34202 int ecode5 = 0 ;
34203 int val6 ;
34204 int ecode6 = 0 ;
34205 PyObject * obj0 = 0 ;
34206 PyObject * obj1 = 0 ;
34207 PyObject * obj2 = 0 ;
34208 PyObject * obj3 = 0 ;
34209 PyObject * obj4 = 0 ;
34210 PyObject * obj5 = 0 ;
34211 char * kwnames[] = {
34212 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
34213 };
34214
34215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
34216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34217 if (!SWIG_IsOK(res1)) {
34218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
34219 }
34220 arg1 = reinterpret_cast< wxWindow * >(argp1);
34221 ecode2 = SWIG_AsVal_int(obj1, &val2);
34222 if (!SWIG_IsOK(ecode2)) {
34223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
34224 }
34225 arg2 = static_cast< int >(val2);
34226 ecode3 = SWIG_AsVal_int(obj2, &val3);
34227 if (!SWIG_IsOK(ecode3)) {
34228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
34229 }
34230 arg3 = static_cast< int >(val3);
34231 ecode4 = SWIG_AsVal_int(obj3, &val4);
34232 if (!SWIG_IsOK(ecode4)) {
34233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
34234 }
34235 arg4 = static_cast< int >(val4);
34236 ecode5 = SWIG_AsVal_int(obj4, &val5);
34237 if (!SWIG_IsOK(ecode5)) {
34238 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
34239 }
34240 arg5 = static_cast< int >(val5);
34241 if (obj5) {
34242 ecode6 = SWIG_AsVal_int(obj5, &val6);
34243 if (!SWIG_IsOK(ecode6)) {
34244 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
34245 }
34246 arg6 = static_cast< int >(val6);
34247 }
34248 {
34249 PyThreadState* __tstate = wxPyBeginAllowThreads();
34250 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
34251 wxPyEndAllowThreads(__tstate);
34252 if (PyErr_Occurred()) SWIG_fail;
34253 }
34254 resultobj = SWIG_Py_Void();
34255 return resultobj;
34256 fail:
34257 return NULL;
34258 }
34259
34260
34261 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34262 PyObject *resultobj = 0;
34263 wxWindow *arg1 = (wxWindow *) 0 ;
34264 wxRect *arg2 = 0 ;
34265 int arg3 = (int) wxSIZE_AUTO ;
34266 void *argp1 = 0 ;
34267 int res1 = 0 ;
34268 wxRect temp2 ;
34269 int val3 ;
34270 int ecode3 = 0 ;
34271 PyObject * obj0 = 0 ;
34272 PyObject * obj1 = 0 ;
34273 PyObject * obj2 = 0 ;
34274 char * kwnames[] = {
34275 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
34276 };
34277
34278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34280 if (!SWIG_IsOK(res1)) {
34281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34282 }
34283 arg1 = reinterpret_cast< wxWindow * >(argp1);
34284 {
34285 arg2 = &temp2;
34286 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34287 }
34288 if (obj2) {
34289 ecode3 = SWIG_AsVal_int(obj2, &val3);
34290 if (!SWIG_IsOK(ecode3)) {
34291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
34292 }
34293 arg3 = static_cast< int >(val3);
34294 }
34295 {
34296 PyThreadState* __tstate = wxPyBeginAllowThreads();
34297 (arg1)->SetSize((wxRect const &)*arg2,arg3);
34298 wxPyEndAllowThreads(__tstate);
34299 if (PyErr_Occurred()) SWIG_fail;
34300 }
34301 resultobj = SWIG_Py_Void();
34302 return resultobj;
34303 fail:
34304 return NULL;
34305 }
34306
34307
34308 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34309 PyObject *resultobj = 0;
34310 wxWindow *arg1 = (wxWindow *) 0 ;
34311 int arg2 ;
34312 int arg3 ;
34313 void *argp1 = 0 ;
34314 int res1 = 0 ;
34315 int val2 ;
34316 int ecode2 = 0 ;
34317 int val3 ;
34318 int ecode3 = 0 ;
34319 PyObject * obj0 = 0 ;
34320 PyObject * obj1 = 0 ;
34321 PyObject * obj2 = 0 ;
34322 char * kwnames[] = {
34323 (char *) "self",(char *) "width",(char *) "height", NULL
34324 };
34325
34326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34328 if (!SWIG_IsOK(res1)) {
34329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34330 }
34331 arg1 = reinterpret_cast< wxWindow * >(argp1);
34332 ecode2 = SWIG_AsVal_int(obj1, &val2);
34333 if (!SWIG_IsOK(ecode2)) {
34334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
34335 }
34336 arg2 = static_cast< int >(val2);
34337 ecode3 = SWIG_AsVal_int(obj2, &val3);
34338 if (!SWIG_IsOK(ecode3)) {
34339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
34340 }
34341 arg3 = static_cast< int >(val3);
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 (arg1)->SetSize(arg2,arg3);
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 resultobj = SWIG_Py_Void();
34349 return resultobj;
34350 fail:
34351 return NULL;
34352 }
34353
34354
34355 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34356 PyObject *resultobj = 0;
34357 wxWindow *arg1 = (wxWindow *) 0 ;
34358 wxPoint *arg2 = 0 ;
34359 int arg3 = (int) wxSIZE_USE_EXISTING ;
34360 void *argp1 = 0 ;
34361 int res1 = 0 ;
34362 wxPoint temp2 ;
34363 int val3 ;
34364 int ecode3 = 0 ;
34365 PyObject * obj0 = 0 ;
34366 PyObject * obj1 = 0 ;
34367 PyObject * obj2 = 0 ;
34368 char * kwnames[] = {
34369 (char *) "self",(char *) "pt",(char *) "flags", NULL
34370 };
34371
34372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34374 if (!SWIG_IsOK(res1)) {
34375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
34376 }
34377 arg1 = reinterpret_cast< wxWindow * >(argp1);
34378 {
34379 arg2 = &temp2;
34380 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34381 }
34382 if (obj2) {
34383 ecode3 = SWIG_AsVal_int(obj2, &val3);
34384 if (!SWIG_IsOK(ecode3)) {
34385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
34386 }
34387 arg3 = static_cast< int >(val3);
34388 }
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 (arg1)->Move((wxPoint const &)*arg2,arg3);
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 resultobj = SWIG_Py_Void();
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 int arg2 ;
34406 int arg3 ;
34407 int arg4 = (int) wxSIZE_USE_EXISTING ;
34408 void *argp1 = 0 ;
34409 int res1 = 0 ;
34410 int val2 ;
34411 int ecode2 = 0 ;
34412 int val3 ;
34413 int ecode3 = 0 ;
34414 int val4 ;
34415 int ecode4 = 0 ;
34416 PyObject * obj0 = 0 ;
34417 PyObject * obj1 = 0 ;
34418 PyObject * obj2 = 0 ;
34419 PyObject * obj3 = 0 ;
34420 char * kwnames[] = {
34421 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
34422 };
34423
34424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34426 if (!SWIG_IsOK(res1)) {
34427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
34428 }
34429 arg1 = reinterpret_cast< wxWindow * >(argp1);
34430 ecode2 = SWIG_AsVal_int(obj1, &val2);
34431 if (!SWIG_IsOK(ecode2)) {
34432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
34433 }
34434 arg2 = static_cast< int >(val2);
34435 ecode3 = SWIG_AsVal_int(obj2, &val3);
34436 if (!SWIG_IsOK(ecode3)) {
34437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
34438 }
34439 arg3 = static_cast< int >(val3);
34440 if (obj3) {
34441 ecode4 = SWIG_AsVal_int(obj3, &val4);
34442 if (!SWIG_IsOK(ecode4)) {
34443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
34444 }
34445 arg4 = static_cast< int >(val4);
34446 }
34447 {
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 (arg1)->Move(arg2,arg3,arg4);
34450 wxPyEndAllowThreads(__tstate);
34451 if (PyErr_Occurred()) SWIG_fail;
34452 }
34453 resultobj = SWIG_Py_Void();
34454 return resultobj;
34455 fail:
34456 return NULL;
34457 }
34458
34459
34460 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34461 PyObject *resultobj = 0;
34462 wxWindow *arg1 = (wxWindow *) 0 ;
34463 wxSize const &arg2_defvalue = wxDefaultSize ;
34464 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34465 void *argp1 = 0 ;
34466 int res1 = 0 ;
34467 wxSize temp2 ;
34468 PyObject * obj0 = 0 ;
34469 PyObject * obj1 = 0 ;
34470 char * kwnames[] = {
34471 (char *) "self",(char *) "size", NULL
34472 };
34473
34474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34476 if (!SWIG_IsOK(res1)) {
34477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34478 }
34479 arg1 = reinterpret_cast< wxWindow * >(argp1);
34480 if (obj1) {
34481 {
34482 arg2 = &temp2;
34483 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34484 }
34485 }
34486 {
34487 PyThreadState* __tstate = wxPyBeginAllowThreads();
34488 (arg1)->SetInitialSize((wxSize const &)*arg2);
34489 wxPyEndAllowThreads(__tstate);
34490 if (PyErr_Occurred()) SWIG_fail;
34491 }
34492 resultobj = SWIG_Py_Void();
34493 return resultobj;
34494 fail:
34495 return NULL;
34496 }
34497
34498
34499 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34500 PyObject *resultobj = 0;
34501 wxWindow *arg1 = (wxWindow *) 0 ;
34502 void *argp1 = 0 ;
34503 int res1 = 0 ;
34504 PyObject *swig_obj[1] ;
34505
34506 if (!args) SWIG_fail;
34507 swig_obj[0] = args;
34508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34509 if (!SWIG_IsOK(res1)) {
34510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34511 }
34512 arg1 = reinterpret_cast< wxWindow * >(argp1);
34513 {
34514 PyThreadState* __tstate = wxPyBeginAllowThreads();
34515 (arg1)->Raise();
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 resultobj = SWIG_Py_Void();
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34527 PyObject *resultobj = 0;
34528 wxWindow *arg1 = (wxWindow *) 0 ;
34529 void *argp1 = 0 ;
34530 int res1 = 0 ;
34531 PyObject *swig_obj[1] ;
34532
34533 if (!args) SWIG_fail;
34534 swig_obj[0] = args;
34535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34536 if (!SWIG_IsOK(res1)) {
34537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34538 }
34539 arg1 = reinterpret_cast< wxWindow * >(argp1);
34540 {
34541 PyThreadState* __tstate = wxPyBeginAllowThreads();
34542 (arg1)->Lower();
34543 wxPyEndAllowThreads(__tstate);
34544 if (PyErr_Occurred()) SWIG_fail;
34545 }
34546 resultobj = SWIG_Py_Void();
34547 return resultobj;
34548 fail:
34549 return NULL;
34550 }
34551
34552
34553 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34554 PyObject *resultobj = 0;
34555 wxWindow *arg1 = (wxWindow *) 0 ;
34556 wxSize *arg2 = 0 ;
34557 void *argp1 = 0 ;
34558 int res1 = 0 ;
34559 wxSize temp2 ;
34560 PyObject * obj0 = 0 ;
34561 PyObject * obj1 = 0 ;
34562 char * kwnames[] = {
34563 (char *) "self",(char *) "size", NULL
34564 };
34565
34566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34568 if (!SWIG_IsOK(res1)) {
34569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34570 }
34571 arg1 = reinterpret_cast< wxWindow * >(argp1);
34572 {
34573 arg2 = &temp2;
34574 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34575 }
34576 {
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 (arg1)->SetClientSize((wxSize const &)*arg2);
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 resultobj = SWIG_Py_Void();
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34590 PyObject *resultobj = 0;
34591 wxWindow *arg1 = (wxWindow *) 0 ;
34592 int arg2 ;
34593 int arg3 ;
34594 void *argp1 = 0 ;
34595 int res1 = 0 ;
34596 int val2 ;
34597 int ecode2 = 0 ;
34598 int val3 ;
34599 int ecode3 = 0 ;
34600 PyObject * obj0 = 0 ;
34601 PyObject * obj1 = 0 ;
34602 PyObject * obj2 = 0 ;
34603 char * kwnames[] = {
34604 (char *) "self",(char *) "width",(char *) "height", NULL
34605 };
34606
34607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34609 if (!SWIG_IsOK(res1)) {
34610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34611 }
34612 arg1 = reinterpret_cast< wxWindow * >(argp1);
34613 ecode2 = SWIG_AsVal_int(obj1, &val2);
34614 if (!SWIG_IsOK(ecode2)) {
34615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34616 }
34617 arg2 = static_cast< int >(val2);
34618 ecode3 = SWIG_AsVal_int(obj2, &val3);
34619 if (!SWIG_IsOK(ecode3)) {
34620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34621 }
34622 arg3 = static_cast< int >(val3);
34623 {
34624 PyThreadState* __tstate = wxPyBeginAllowThreads();
34625 (arg1)->SetClientSize(arg2,arg3);
34626 wxPyEndAllowThreads(__tstate);
34627 if (PyErr_Occurred()) SWIG_fail;
34628 }
34629 resultobj = SWIG_Py_Void();
34630 return resultobj;
34631 fail:
34632 return NULL;
34633 }
34634
34635
34636 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34637 PyObject *resultobj = 0;
34638 wxWindow *arg1 = (wxWindow *) 0 ;
34639 wxRect *arg2 = 0 ;
34640 void *argp1 = 0 ;
34641 int res1 = 0 ;
34642 wxRect temp2 ;
34643 PyObject * obj0 = 0 ;
34644 PyObject * obj1 = 0 ;
34645 char * kwnames[] = {
34646 (char *) "self",(char *) "rect", NULL
34647 };
34648
34649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34651 if (!SWIG_IsOK(res1)) {
34652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34653 }
34654 arg1 = reinterpret_cast< wxWindow * >(argp1);
34655 {
34656 arg2 = &temp2;
34657 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34658 }
34659 {
34660 PyThreadState* __tstate = wxPyBeginAllowThreads();
34661 (arg1)->SetClientSize((wxRect const &)*arg2);
34662 wxPyEndAllowThreads(__tstate);
34663 if (PyErr_Occurred()) SWIG_fail;
34664 }
34665 resultobj = SWIG_Py_Void();
34666 return resultobj;
34667 fail:
34668 return NULL;
34669 }
34670
34671
34672 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34673 PyObject *resultobj = 0;
34674 wxWindow *arg1 = (wxWindow *) 0 ;
34675 wxPoint result;
34676 void *argp1 = 0 ;
34677 int res1 = 0 ;
34678 PyObject *swig_obj[1] ;
34679
34680 if (!args) SWIG_fail;
34681 swig_obj[0] = args;
34682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34683 if (!SWIG_IsOK(res1)) {
34684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34685 }
34686 arg1 = reinterpret_cast< wxWindow * >(argp1);
34687 {
34688 PyThreadState* __tstate = wxPyBeginAllowThreads();
34689 result = ((wxWindow const *)arg1)->GetPosition();
34690 wxPyEndAllowThreads(__tstate);
34691 if (PyErr_Occurred()) SWIG_fail;
34692 }
34693 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34694 return resultobj;
34695 fail:
34696 return NULL;
34697 }
34698
34699
34700 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34701 PyObject *resultobj = 0;
34702 wxWindow *arg1 = (wxWindow *) 0 ;
34703 int *arg2 = (int *) 0 ;
34704 int *arg3 = (int *) 0 ;
34705 void *argp1 = 0 ;
34706 int res1 = 0 ;
34707 int temp2 ;
34708 int res2 = SWIG_TMPOBJ ;
34709 int temp3 ;
34710 int res3 = SWIG_TMPOBJ ;
34711 PyObject *swig_obj[1] ;
34712
34713 arg2 = &temp2;
34714 arg3 = &temp3;
34715 if (!args) SWIG_fail;
34716 swig_obj[0] = args;
34717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34718 if (!SWIG_IsOK(res1)) {
34719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34720 }
34721 arg1 = reinterpret_cast< wxWindow * >(argp1);
34722 {
34723 PyThreadState* __tstate = wxPyBeginAllowThreads();
34724 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34725 wxPyEndAllowThreads(__tstate);
34726 if (PyErr_Occurred()) SWIG_fail;
34727 }
34728 resultobj = SWIG_Py_Void();
34729 if (SWIG_IsTmpObj(res2)) {
34730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34731 } else {
34732 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34734 }
34735 if (SWIG_IsTmpObj(res3)) {
34736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34737 } else {
34738 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34740 }
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34748 PyObject *resultobj = 0;
34749 wxWindow *arg1 = (wxWindow *) 0 ;
34750 wxPoint result;
34751 void *argp1 = 0 ;
34752 int res1 = 0 ;
34753 PyObject *swig_obj[1] ;
34754
34755 if (!args) SWIG_fail;
34756 swig_obj[0] = args;
34757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34758 if (!SWIG_IsOK(res1)) {
34759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34760 }
34761 arg1 = reinterpret_cast< wxWindow * >(argp1);
34762 {
34763 PyThreadState* __tstate = wxPyBeginAllowThreads();
34764 result = ((wxWindow const *)arg1)->GetScreenPosition();
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34776 PyObject *resultobj = 0;
34777 wxWindow *arg1 = (wxWindow *) 0 ;
34778 int *arg2 = (int *) 0 ;
34779 int *arg3 = (int *) 0 ;
34780 void *argp1 = 0 ;
34781 int res1 = 0 ;
34782 int temp2 ;
34783 int res2 = SWIG_TMPOBJ ;
34784 int temp3 ;
34785 int res3 = SWIG_TMPOBJ ;
34786 PyObject *swig_obj[1] ;
34787
34788 arg2 = &temp2;
34789 arg3 = &temp3;
34790 if (!args) SWIG_fail;
34791 swig_obj[0] = args;
34792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34795 }
34796 arg1 = reinterpret_cast< wxWindow * >(argp1);
34797 {
34798 PyThreadState* __tstate = wxPyBeginAllowThreads();
34799 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34800 wxPyEndAllowThreads(__tstate);
34801 if (PyErr_Occurred()) SWIG_fail;
34802 }
34803 resultobj = SWIG_Py_Void();
34804 if (SWIG_IsTmpObj(res2)) {
34805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34806 } else {
34807 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34809 }
34810 if (SWIG_IsTmpObj(res3)) {
34811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34812 } else {
34813 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34815 }
34816 return resultobj;
34817 fail:
34818 return NULL;
34819 }
34820
34821
34822 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34823 PyObject *resultobj = 0;
34824 wxWindow *arg1 = (wxWindow *) 0 ;
34825 wxRect result;
34826 void *argp1 = 0 ;
34827 int res1 = 0 ;
34828 PyObject *swig_obj[1] ;
34829
34830 if (!args) SWIG_fail;
34831 swig_obj[0] = args;
34832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34833 if (!SWIG_IsOK(res1)) {
34834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34835 }
34836 arg1 = reinterpret_cast< wxWindow * >(argp1);
34837 {
34838 PyThreadState* __tstate = wxPyBeginAllowThreads();
34839 result = ((wxWindow const *)arg1)->GetScreenRect();
34840 wxPyEndAllowThreads(__tstate);
34841 if (PyErr_Occurred()) SWIG_fail;
34842 }
34843 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34844 return resultobj;
34845 fail:
34846 return NULL;
34847 }
34848
34849
34850 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34851 PyObject *resultobj = 0;
34852 wxWindow *arg1 = (wxWindow *) 0 ;
34853 wxSize result;
34854 void *argp1 = 0 ;
34855 int res1 = 0 ;
34856 PyObject *swig_obj[1] ;
34857
34858 if (!args) SWIG_fail;
34859 swig_obj[0] = args;
34860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34861 if (!SWIG_IsOK(res1)) {
34862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34863 }
34864 arg1 = reinterpret_cast< wxWindow * >(argp1);
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 result = ((wxWindow const *)arg1)->GetSize();
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34872 return resultobj;
34873 fail:
34874 return NULL;
34875 }
34876
34877
34878 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34879 PyObject *resultobj = 0;
34880 wxWindow *arg1 = (wxWindow *) 0 ;
34881 int *arg2 = (int *) 0 ;
34882 int *arg3 = (int *) 0 ;
34883 void *argp1 = 0 ;
34884 int res1 = 0 ;
34885 int temp2 ;
34886 int res2 = SWIG_TMPOBJ ;
34887 int temp3 ;
34888 int res3 = SWIG_TMPOBJ ;
34889 PyObject *swig_obj[1] ;
34890
34891 arg2 = &temp2;
34892 arg3 = &temp3;
34893 if (!args) SWIG_fail;
34894 swig_obj[0] = args;
34895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34896 if (!SWIG_IsOK(res1)) {
34897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34898 }
34899 arg1 = reinterpret_cast< wxWindow * >(argp1);
34900 {
34901 PyThreadState* __tstate = wxPyBeginAllowThreads();
34902 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34903 wxPyEndAllowThreads(__tstate);
34904 if (PyErr_Occurred()) SWIG_fail;
34905 }
34906 resultobj = SWIG_Py_Void();
34907 if (SWIG_IsTmpObj(res2)) {
34908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34909 } else {
34910 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34912 }
34913 if (SWIG_IsTmpObj(res3)) {
34914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34915 } else {
34916 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34918 }
34919 return resultobj;
34920 fail:
34921 return NULL;
34922 }
34923
34924
34925 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34926 PyObject *resultobj = 0;
34927 wxWindow *arg1 = (wxWindow *) 0 ;
34928 wxRect result;
34929 void *argp1 = 0 ;
34930 int res1 = 0 ;
34931 PyObject *swig_obj[1] ;
34932
34933 if (!args) SWIG_fail;
34934 swig_obj[0] = args;
34935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34936 if (!SWIG_IsOK(res1)) {
34937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34938 }
34939 arg1 = reinterpret_cast< wxWindow * >(argp1);
34940 {
34941 PyThreadState* __tstate = wxPyBeginAllowThreads();
34942 result = ((wxWindow const *)arg1)->GetRect();
34943 wxPyEndAllowThreads(__tstate);
34944 if (PyErr_Occurred()) SWIG_fail;
34945 }
34946 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34947 return resultobj;
34948 fail:
34949 return NULL;
34950 }
34951
34952
34953 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34954 PyObject *resultobj = 0;
34955 wxWindow *arg1 = (wxWindow *) 0 ;
34956 wxSize result;
34957 void *argp1 = 0 ;
34958 int res1 = 0 ;
34959 PyObject *swig_obj[1] ;
34960
34961 if (!args) SWIG_fail;
34962 swig_obj[0] = args;
34963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34964 if (!SWIG_IsOK(res1)) {
34965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34966 }
34967 arg1 = reinterpret_cast< wxWindow * >(argp1);
34968 {
34969 PyThreadState* __tstate = wxPyBeginAllowThreads();
34970 result = ((wxWindow const *)arg1)->GetClientSize();
34971 wxPyEndAllowThreads(__tstate);
34972 if (PyErr_Occurred()) SWIG_fail;
34973 }
34974 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34975 return resultobj;
34976 fail:
34977 return NULL;
34978 }
34979
34980
34981 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34982 PyObject *resultobj = 0;
34983 wxWindow *arg1 = (wxWindow *) 0 ;
34984 int *arg2 = (int *) 0 ;
34985 int *arg3 = (int *) 0 ;
34986 void *argp1 = 0 ;
34987 int res1 = 0 ;
34988 int temp2 ;
34989 int res2 = SWIG_TMPOBJ ;
34990 int temp3 ;
34991 int res3 = SWIG_TMPOBJ ;
34992 PyObject *swig_obj[1] ;
34993
34994 arg2 = &temp2;
34995 arg3 = &temp3;
34996 if (!args) SWIG_fail;
34997 swig_obj[0] = args;
34998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34999 if (!SWIG_IsOK(res1)) {
35000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35001 }
35002 arg1 = reinterpret_cast< wxWindow * >(argp1);
35003 {
35004 PyThreadState* __tstate = wxPyBeginAllowThreads();
35005 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
35006 wxPyEndAllowThreads(__tstate);
35007 if (PyErr_Occurred()) SWIG_fail;
35008 }
35009 resultobj = SWIG_Py_Void();
35010 if (SWIG_IsTmpObj(res2)) {
35011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35012 } else {
35013 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35015 }
35016 if (SWIG_IsTmpObj(res3)) {
35017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35018 } else {
35019 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35021 }
35022 return resultobj;
35023 fail:
35024 return NULL;
35025 }
35026
35027
35028 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35029 PyObject *resultobj = 0;
35030 wxWindow *arg1 = (wxWindow *) 0 ;
35031 wxPoint result;
35032 void *argp1 = 0 ;
35033 int res1 = 0 ;
35034 PyObject *swig_obj[1] ;
35035
35036 if (!args) SWIG_fail;
35037 swig_obj[0] = args;
35038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35039 if (!SWIG_IsOK(res1)) {
35040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
35041 }
35042 arg1 = reinterpret_cast< wxWindow * >(argp1);
35043 {
35044 PyThreadState* __tstate = wxPyBeginAllowThreads();
35045 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
35046 wxPyEndAllowThreads(__tstate);
35047 if (PyErr_Occurred()) SWIG_fail;
35048 }
35049 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35050 return resultobj;
35051 fail:
35052 return NULL;
35053 }
35054
35055
35056 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35057 PyObject *resultobj = 0;
35058 wxWindow *arg1 = (wxWindow *) 0 ;
35059 wxRect result;
35060 void *argp1 = 0 ;
35061 int res1 = 0 ;
35062 PyObject *swig_obj[1] ;
35063
35064 if (!args) SWIG_fail;
35065 swig_obj[0] = args;
35066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35067 if (!SWIG_IsOK(res1)) {
35068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35069 }
35070 arg1 = reinterpret_cast< wxWindow * >(argp1);
35071 {
35072 PyThreadState* __tstate = wxPyBeginAllowThreads();
35073 result = ((wxWindow const *)arg1)->GetClientRect();
35074 wxPyEndAllowThreads(__tstate);
35075 if (PyErr_Occurred()) SWIG_fail;
35076 }
35077 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35078 return resultobj;
35079 fail:
35080 return NULL;
35081 }
35082
35083
35084 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35085 PyObject *resultobj = 0;
35086 wxWindow *arg1 = (wxWindow *) 0 ;
35087 wxSize result;
35088 void *argp1 = 0 ;
35089 int res1 = 0 ;
35090 PyObject *swig_obj[1] ;
35091
35092 if (!args) SWIG_fail;
35093 swig_obj[0] = args;
35094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35095 if (!SWIG_IsOK(res1)) {
35096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35097 }
35098 arg1 = reinterpret_cast< wxWindow * >(argp1);
35099 {
35100 PyThreadState* __tstate = wxPyBeginAllowThreads();
35101 result = ((wxWindow const *)arg1)->GetBestSize();
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35113 PyObject *resultobj = 0;
35114 wxWindow *arg1 = (wxWindow *) 0 ;
35115 int *arg2 = (int *) 0 ;
35116 int *arg3 = (int *) 0 ;
35117 void *argp1 = 0 ;
35118 int res1 = 0 ;
35119 int temp2 ;
35120 int res2 = SWIG_TMPOBJ ;
35121 int temp3 ;
35122 int res3 = SWIG_TMPOBJ ;
35123 PyObject *swig_obj[1] ;
35124
35125 arg2 = &temp2;
35126 arg3 = &temp3;
35127 if (!args) SWIG_fail;
35128 swig_obj[0] = args;
35129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35130 if (!SWIG_IsOK(res1)) {
35131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35132 }
35133 arg1 = reinterpret_cast< wxWindow * >(argp1);
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
35137 wxPyEndAllowThreads(__tstate);
35138 if (PyErr_Occurred()) SWIG_fail;
35139 }
35140 resultobj = SWIG_Py_Void();
35141 if (SWIG_IsTmpObj(res2)) {
35142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35143 } else {
35144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35146 }
35147 if (SWIG_IsTmpObj(res3)) {
35148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35149 } else {
35150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35152 }
35153 return resultobj;
35154 fail:
35155 return NULL;
35156 }
35157
35158
35159 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35160 PyObject *resultobj = 0;
35161 wxWindow *arg1 = (wxWindow *) 0 ;
35162 void *argp1 = 0 ;
35163 int res1 = 0 ;
35164 PyObject *swig_obj[1] ;
35165
35166 if (!args) SWIG_fail;
35167 swig_obj[0] = args;
35168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35169 if (!SWIG_IsOK(res1)) {
35170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35171 }
35172 arg1 = reinterpret_cast< wxWindow * >(argp1);
35173 {
35174 PyThreadState* __tstate = wxPyBeginAllowThreads();
35175 (arg1)->InvalidateBestSize();
35176 wxPyEndAllowThreads(__tstate);
35177 if (PyErr_Occurred()) SWIG_fail;
35178 }
35179 resultobj = SWIG_Py_Void();
35180 return resultobj;
35181 fail:
35182 return NULL;
35183 }
35184
35185
35186 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35187 PyObject *resultobj = 0;
35188 wxWindow *arg1 = (wxWindow *) 0 ;
35189 wxSize *arg2 = 0 ;
35190 void *argp1 = 0 ;
35191 int res1 = 0 ;
35192 wxSize temp2 ;
35193 PyObject * obj0 = 0 ;
35194 PyObject * obj1 = 0 ;
35195 char * kwnames[] = {
35196 (char *) "self",(char *) "size", NULL
35197 };
35198
35199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
35200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35201 if (!SWIG_IsOK(res1)) {
35202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35203 }
35204 arg1 = reinterpret_cast< wxWindow * >(argp1);
35205 {
35206 arg2 = &temp2;
35207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35208 }
35209 {
35210 PyThreadState* __tstate = wxPyBeginAllowThreads();
35211 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
35212 wxPyEndAllowThreads(__tstate);
35213 if (PyErr_Occurred()) SWIG_fail;
35214 }
35215 resultobj = SWIG_Py_Void();
35216 return resultobj;
35217 fail:
35218 return NULL;
35219 }
35220
35221
35222 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35223 PyObject *resultobj = 0;
35224 wxWindow *arg1 = (wxWindow *) 0 ;
35225 wxSize result;
35226 void *argp1 = 0 ;
35227 int res1 = 0 ;
35228 PyObject *swig_obj[1] ;
35229
35230 if (!args) SWIG_fail;
35231 swig_obj[0] = args;
35232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35233 if (!SWIG_IsOK(res1)) {
35234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35235 }
35236 arg1 = reinterpret_cast< wxWindow * >(argp1);
35237 {
35238 PyThreadState* __tstate = wxPyBeginAllowThreads();
35239 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35244 return resultobj;
35245 fail:
35246 return NULL;
35247 }
35248
35249
35250 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35251 PyObject *resultobj = 0;
35252 wxWindow *arg1 = (wxWindow *) 0 ;
35253 int arg2 = (int) wxBOTH ;
35254 void *argp1 = 0 ;
35255 int res1 = 0 ;
35256 int val2 ;
35257 int ecode2 = 0 ;
35258 PyObject * obj0 = 0 ;
35259 PyObject * obj1 = 0 ;
35260 char * kwnames[] = {
35261 (char *) "self",(char *) "direction", NULL
35262 };
35263
35264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
35265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35266 if (!SWIG_IsOK(res1)) {
35267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
35268 }
35269 arg1 = reinterpret_cast< wxWindow * >(argp1);
35270 if (obj1) {
35271 ecode2 = SWIG_AsVal_int(obj1, &val2);
35272 if (!SWIG_IsOK(ecode2)) {
35273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
35274 }
35275 arg2 = static_cast< int >(val2);
35276 }
35277 {
35278 PyThreadState* __tstate = wxPyBeginAllowThreads();
35279 (arg1)->Center(arg2);
35280 wxPyEndAllowThreads(__tstate);
35281 if (PyErr_Occurred()) SWIG_fail;
35282 }
35283 resultobj = SWIG_Py_Void();
35284 return resultobj;
35285 fail:
35286 return NULL;
35287 }
35288
35289
35290 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35291 PyObject *resultobj = 0;
35292 wxWindow *arg1 = (wxWindow *) 0 ;
35293 int arg2 = (int) wxBOTH ;
35294 void *argp1 = 0 ;
35295 int res1 = 0 ;
35296 int val2 ;
35297 int ecode2 = 0 ;
35298 PyObject * obj0 = 0 ;
35299 PyObject * obj1 = 0 ;
35300 char * kwnames[] = {
35301 (char *) "self",(char *) "dir", NULL
35302 };
35303
35304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
35305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35306 if (!SWIG_IsOK(res1)) {
35307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
35308 }
35309 arg1 = reinterpret_cast< wxWindow * >(argp1);
35310 if (obj1) {
35311 ecode2 = SWIG_AsVal_int(obj1, &val2);
35312 if (!SWIG_IsOK(ecode2)) {
35313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
35314 }
35315 arg2 = static_cast< int >(val2);
35316 }
35317 {
35318 PyThreadState* __tstate = wxPyBeginAllowThreads();
35319 (arg1)->CenterOnParent(arg2);
35320 wxPyEndAllowThreads(__tstate);
35321 if (PyErr_Occurred()) SWIG_fail;
35322 }
35323 resultobj = SWIG_Py_Void();
35324 return resultobj;
35325 fail:
35326 return NULL;
35327 }
35328
35329
35330 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35331 PyObject *resultobj = 0;
35332 wxWindow *arg1 = (wxWindow *) 0 ;
35333 void *argp1 = 0 ;
35334 int res1 = 0 ;
35335 PyObject *swig_obj[1] ;
35336
35337 if (!args) SWIG_fail;
35338 swig_obj[0] = args;
35339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35340 if (!SWIG_IsOK(res1)) {
35341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
35342 }
35343 arg1 = reinterpret_cast< wxWindow * >(argp1);
35344 {
35345 PyThreadState* __tstate = wxPyBeginAllowThreads();
35346 (arg1)->Fit();
35347 wxPyEndAllowThreads(__tstate);
35348 if (PyErr_Occurred()) SWIG_fail;
35349 }
35350 resultobj = SWIG_Py_Void();
35351 return resultobj;
35352 fail:
35353 return NULL;
35354 }
35355
35356
35357 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35358 PyObject *resultobj = 0;
35359 wxWindow *arg1 = (wxWindow *) 0 ;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 PyObject *swig_obj[1] ;
35363
35364 if (!args) SWIG_fail;
35365 swig_obj[0] = args;
35366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35367 if (!SWIG_IsOK(res1)) {
35368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
35369 }
35370 arg1 = reinterpret_cast< wxWindow * >(argp1);
35371 {
35372 PyThreadState* __tstate = wxPyBeginAllowThreads();
35373 (arg1)->FitInside();
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 resultobj = SWIG_Py_Void();
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35385 PyObject *resultobj = 0;
35386 wxWindow *arg1 = (wxWindow *) 0 ;
35387 int arg2 ;
35388 int arg3 ;
35389 int arg4 = (int) -1 ;
35390 int arg5 = (int) -1 ;
35391 int arg6 = (int) -1 ;
35392 int arg7 = (int) -1 ;
35393 void *argp1 = 0 ;
35394 int res1 = 0 ;
35395 int val2 ;
35396 int ecode2 = 0 ;
35397 int val3 ;
35398 int ecode3 = 0 ;
35399 int val4 ;
35400 int ecode4 = 0 ;
35401 int val5 ;
35402 int ecode5 = 0 ;
35403 int val6 ;
35404 int ecode6 = 0 ;
35405 int val7 ;
35406 int ecode7 = 0 ;
35407 PyObject * obj0 = 0 ;
35408 PyObject * obj1 = 0 ;
35409 PyObject * obj2 = 0 ;
35410 PyObject * obj3 = 0 ;
35411 PyObject * obj4 = 0 ;
35412 PyObject * obj5 = 0 ;
35413 PyObject * obj6 = 0 ;
35414 char * kwnames[] = {
35415 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
35416 };
35417
35418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
35419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35420 if (!SWIG_IsOK(res1)) {
35421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35422 }
35423 arg1 = reinterpret_cast< wxWindow * >(argp1);
35424 ecode2 = SWIG_AsVal_int(obj1, &val2);
35425 if (!SWIG_IsOK(ecode2)) {
35426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
35427 }
35428 arg2 = static_cast< int >(val2);
35429 ecode3 = SWIG_AsVal_int(obj2, &val3);
35430 if (!SWIG_IsOK(ecode3)) {
35431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
35432 }
35433 arg3 = static_cast< int >(val3);
35434 if (obj3) {
35435 ecode4 = SWIG_AsVal_int(obj3, &val4);
35436 if (!SWIG_IsOK(ecode4)) {
35437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
35438 }
35439 arg4 = static_cast< int >(val4);
35440 }
35441 if (obj4) {
35442 ecode5 = SWIG_AsVal_int(obj4, &val5);
35443 if (!SWIG_IsOK(ecode5)) {
35444 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
35445 }
35446 arg5 = static_cast< int >(val5);
35447 }
35448 if (obj5) {
35449 ecode6 = SWIG_AsVal_int(obj5, &val6);
35450 if (!SWIG_IsOK(ecode6)) {
35451 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
35452 }
35453 arg6 = static_cast< int >(val6);
35454 }
35455 if (obj6) {
35456 ecode7 = SWIG_AsVal_int(obj6, &val7);
35457 if (!SWIG_IsOK(ecode7)) {
35458 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
35459 }
35460 arg7 = static_cast< int >(val7);
35461 }
35462 {
35463 PyThreadState* __tstate = wxPyBeginAllowThreads();
35464 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 resultobj = SWIG_Py_Void();
35469 return resultobj;
35470 fail:
35471 return NULL;
35472 }
35473
35474
35475 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35476 PyObject *resultobj = 0;
35477 wxWindow *arg1 = (wxWindow *) 0 ;
35478 wxSize *arg2 = 0 ;
35479 wxSize const &arg3_defvalue = wxDefaultSize ;
35480 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35481 wxSize const &arg4_defvalue = wxDefaultSize ;
35482 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35483 void *argp1 = 0 ;
35484 int res1 = 0 ;
35485 wxSize temp2 ;
35486 wxSize temp3 ;
35487 wxSize temp4 ;
35488 PyObject * obj0 = 0 ;
35489 PyObject * obj1 = 0 ;
35490 PyObject * obj2 = 0 ;
35491 PyObject * obj3 = 0 ;
35492 char * kwnames[] = {
35493 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35494 };
35495
35496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35498 if (!SWIG_IsOK(res1)) {
35499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35500 }
35501 arg1 = reinterpret_cast< wxWindow * >(argp1);
35502 {
35503 arg2 = &temp2;
35504 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35505 }
35506 if (obj2) {
35507 {
35508 arg3 = &temp3;
35509 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35510 }
35511 }
35512 if (obj3) {
35513 {
35514 arg4 = &temp4;
35515 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35516 }
35517 }
35518 {
35519 PyThreadState* __tstate = wxPyBeginAllowThreads();
35520 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35521 wxPyEndAllowThreads(__tstate);
35522 if (PyErr_Occurred()) SWIG_fail;
35523 }
35524 resultobj = SWIG_Py_Void();
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35532 PyObject *resultobj = 0;
35533 wxWindow *arg1 = (wxWindow *) 0 ;
35534 int arg2 ;
35535 int arg3 ;
35536 int arg4 = (int) -1 ;
35537 int arg5 = (int) -1 ;
35538 void *argp1 = 0 ;
35539 int res1 = 0 ;
35540 int val2 ;
35541 int ecode2 = 0 ;
35542 int val3 ;
35543 int ecode3 = 0 ;
35544 int val4 ;
35545 int ecode4 = 0 ;
35546 int val5 ;
35547 int ecode5 = 0 ;
35548 PyObject * obj0 = 0 ;
35549 PyObject * obj1 = 0 ;
35550 PyObject * obj2 = 0 ;
35551 PyObject * obj3 = 0 ;
35552 PyObject * obj4 = 0 ;
35553 char * kwnames[] = {
35554 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35555 };
35556
35557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35559 if (!SWIG_IsOK(res1)) {
35560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35561 }
35562 arg1 = reinterpret_cast< wxWindow * >(argp1);
35563 ecode2 = SWIG_AsVal_int(obj1, &val2);
35564 if (!SWIG_IsOK(ecode2)) {
35565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35566 }
35567 arg2 = static_cast< int >(val2);
35568 ecode3 = SWIG_AsVal_int(obj2, &val3);
35569 if (!SWIG_IsOK(ecode3)) {
35570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35571 }
35572 arg3 = static_cast< int >(val3);
35573 if (obj3) {
35574 ecode4 = SWIG_AsVal_int(obj3, &val4);
35575 if (!SWIG_IsOK(ecode4)) {
35576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35577 }
35578 arg4 = static_cast< int >(val4);
35579 }
35580 if (obj4) {
35581 ecode5 = SWIG_AsVal_int(obj4, &val5);
35582 if (!SWIG_IsOK(ecode5)) {
35583 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35584 }
35585 arg5 = static_cast< int >(val5);
35586 }
35587 {
35588 PyThreadState* __tstate = wxPyBeginAllowThreads();
35589 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35590 wxPyEndAllowThreads(__tstate);
35591 if (PyErr_Occurred()) SWIG_fail;
35592 }
35593 resultobj = SWIG_Py_Void();
35594 return resultobj;
35595 fail:
35596 return NULL;
35597 }
35598
35599
35600 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35601 PyObject *resultobj = 0;
35602 wxWindow *arg1 = (wxWindow *) 0 ;
35603 wxSize *arg2 = 0 ;
35604 wxSize const &arg3_defvalue = wxDefaultSize ;
35605 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35606 void *argp1 = 0 ;
35607 int res1 = 0 ;
35608 wxSize temp2 ;
35609 wxSize temp3 ;
35610 PyObject * obj0 = 0 ;
35611 PyObject * obj1 = 0 ;
35612 PyObject * obj2 = 0 ;
35613 char * kwnames[] = {
35614 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35615 };
35616
35617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35619 if (!SWIG_IsOK(res1)) {
35620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35621 }
35622 arg1 = reinterpret_cast< wxWindow * >(argp1);
35623 {
35624 arg2 = &temp2;
35625 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35626 }
35627 if (obj2) {
35628 {
35629 arg3 = &temp3;
35630 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35631 }
35632 }
35633 {
35634 PyThreadState* __tstate = wxPyBeginAllowThreads();
35635 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35636 wxPyEndAllowThreads(__tstate);
35637 if (PyErr_Occurred()) SWIG_fail;
35638 }
35639 resultobj = SWIG_Py_Void();
35640 return resultobj;
35641 fail:
35642 return NULL;
35643 }
35644
35645
35646 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35647 PyObject *resultobj = 0;
35648 wxWindow *arg1 = (wxWindow *) 0 ;
35649 wxSize result;
35650 void *argp1 = 0 ;
35651 int res1 = 0 ;
35652 PyObject *swig_obj[1] ;
35653
35654 if (!args) SWIG_fail;
35655 swig_obj[0] = args;
35656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35657 if (!SWIG_IsOK(res1)) {
35658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35659 }
35660 arg1 = reinterpret_cast< wxWindow * >(argp1);
35661 {
35662 PyThreadState* __tstate = wxPyBeginAllowThreads();
35663 result = ((wxWindow const *)arg1)->GetMaxSize();
35664 wxPyEndAllowThreads(__tstate);
35665 if (PyErr_Occurred()) SWIG_fail;
35666 }
35667 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35668 return resultobj;
35669 fail:
35670 return NULL;
35671 }
35672
35673
35674 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35675 PyObject *resultobj = 0;
35676 wxWindow *arg1 = (wxWindow *) 0 ;
35677 wxSize result;
35678 void *argp1 = 0 ;
35679 int res1 = 0 ;
35680 PyObject *swig_obj[1] ;
35681
35682 if (!args) SWIG_fail;
35683 swig_obj[0] = args;
35684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 {
35690 PyThreadState* __tstate = wxPyBeginAllowThreads();
35691 result = ((wxWindow const *)arg1)->GetMinSize();
35692 wxPyEndAllowThreads(__tstate);
35693 if (PyErr_Occurred()) SWIG_fail;
35694 }
35695 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35696 return resultobj;
35697 fail:
35698 return NULL;
35699 }
35700
35701
35702 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35703 PyObject *resultobj = 0;
35704 wxWindow *arg1 = (wxWindow *) 0 ;
35705 wxSize *arg2 = 0 ;
35706 void *argp1 = 0 ;
35707 int res1 = 0 ;
35708 wxSize temp2 ;
35709 PyObject * obj0 = 0 ;
35710 PyObject * obj1 = 0 ;
35711 char * kwnames[] = {
35712 (char *) "self",(char *) "minSize", NULL
35713 };
35714
35715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35717 if (!SWIG_IsOK(res1)) {
35718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35719 }
35720 arg1 = reinterpret_cast< wxWindow * >(argp1);
35721 {
35722 arg2 = &temp2;
35723 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35724 }
35725 {
35726 PyThreadState* __tstate = wxPyBeginAllowThreads();
35727 (arg1)->SetMinSize((wxSize const &)*arg2);
35728 wxPyEndAllowThreads(__tstate);
35729 if (PyErr_Occurred()) SWIG_fail;
35730 }
35731 resultobj = SWIG_Py_Void();
35732 return resultobj;
35733 fail:
35734 return NULL;
35735 }
35736
35737
35738 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35739 PyObject *resultobj = 0;
35740 wxWindow *arg1 = (wxWindow *) 0 ;
35741 wxSize *arg2 = 0 ;
35742 void *argp1 = 0 ;
35743 int res1 = 0 ;
35744 wxSize temp2 ;
35745 PyObject * obj0 = 0 ;
35746 PyObject * obj1 = 0 ;
35747 char * kwnames[] = {
35748 (char *) "self",(char *) "maxSize", NULL
35749 };
35750
35751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35753 if (!SWIG_IsOK(res1)) {
35754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35755 }
35756 arg1 = reinterpret_cast< wxWindow * >(argp1);
35757 {
35758 arg2 = &temp2;
35759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35760 }
35761 {
35762 PyThreadState* __tstate = wxPyBeginAllowThreads();
35763 (arg1)->SetMaxSize((wxSize const &)*arg2);
35764 wxPyEndAllowThreads(__tstate);
35765 if (PyErr_Occurred()) SWIG_fail;
35766 }
35767 resultobj = SWIG_Py_Void();
35768 return resultobj;
35769 fail:
35770 return NULL;
35771 }
35772
35773
35774 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35775 PyObject *resultobj = 0;
35776 wxWindow *arg1 = (wxWindow *) 0 ;
35777 int result;
35778 void *argp1 = 0 ;
35779 int res1 = 0 ;
35780 PyObject *swig_obj[1] ;
35781
35782 if (!args) SWIG_fail;
35783 swig_obj[0] = args;
35784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35785 if (!SWIG_IsOK(res1)) {
35786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35787 }
35788 arg1 = reinterpret_cast< wxWindow * >(argp1);
35789 {
35790 PyThreadState* __tstate = wxPyBeginAllowThreads();
35791 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35792 wxPyEndAllowThreads(__tstate);
35793 if (PyErr_Occurred()) SWIG_fail;
35794 }
35795 resultobj = SWIG_From_int(static_cast< int >(result));
35796 return resultobj;
35797 fail:
35798 return NULL;
35799 }
35800
35801
35802 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35803 PyObject *resultobj = 0;
35804 wxWindow *arg1 = (wxWindow *) 0 ;
35805 int result;
35806 void *argp1 = 0 ;
35807 int res1 = 0 ;
35808 PyObject *swig_obj[1] ;
35809
35810 if (!args) SWIG_fail;
35811 swig_obj[0] = args;
35812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35813 if (!SWIG_IsOK(res1)) {
35814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35815 }
35816 arg1 = reinterpret_cast< wxWindow * >(argp1);
35817 {
35818 PyThreadState* __tstate = wxPyBeginAllowThreads();
35819 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35820 wxPyEndAllowThreads(__tstate);
35821 if (PyErr_Occurred()) SWIG_fail;
35822 }
35823 resultobj = SWIG_From_int(static_cast< int >(result));
35824 return resultobj;
35825 fail:
35826 return NULL;
35827 }
35828
35829
35830 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35831 PyObject *resultobj = 0;
35832 wxWindow *arg1 = (wxWindow *) 0 ;
35833 int result;
35834 void *argp1 = 0 ;
35835 int res1 = 0 ;
35836 PyObject *swig_obj[1] ;
35837
35838 if (!args) SWIG_fail;
35839 swig_obj[0] = args;
35840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35843 }
35844 arg1 = reinterpret_cast< wxWindow * >(argp1);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 resultobj = SWIG_From_int(static_cast< int >(result));
35852 return resultobj;
35853 fail:
35854 return NULL;
35855 }
35856
35857
35858 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35859 PyObject *resultobj = 0;
35860 wxWindow *arg1 = (wxWindow *) 0 ;
35861 int result;
35862 void *argp1 = 0 ;
35863 int res1 = 0 ;
35864 PyObject *swig_obj[1] ;
35865
35866 if (!args) SWIG_fail;
35867 swig_obj[0] = args;
35868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35869 if (!SWIG_IsOK(res1)) {
35870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35871 }
35872 arg1 = reinterpret_cast< wxWindow * >(argp1);
35873 {
35874 PyThreadState* __tstate = wxPyBeginAllowThreads();
35875 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35876 wxPyEndAllowThreads(__tstate);
35877 if (PyErr_Occurred()) SWIG_fail;
35878 }
35879 resultobj = SWIG_From_int(static_cast< int >(result));
35880 return resultobj;
35881 fail:
35882 return NULL;
35883 }
35884
35885
35886 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35887 PyObject *resultobj = 0;
35888 wxWindow *arg1 = (wxWindow *) 0 ;
35889 wxSize *arg2 = 0 ;
35890 void *argp1 = 0 ;
35891 int res1 = 0 ;
35892 wxSize temp2 ;
35893 PyObject * obj0 = 0 ;
35894 PyObject * obj1 = 0 ;
35895 char * kwnames[] = {
35896 (char *) "self",(char *) "size", NULL
35897 };
35898
35899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35901 if (!SWIG_IsOK(res1)) {
35902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35903 }
35904 arg1 = reinterpret_cast< wxWindow * >(argp1);
35905 {
35906 arg2 = &temp2;
35907 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35908 }
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35912 wxPyEndAllowThreads(__tstate);
35913 if (PyErr_Occurred()) SWIG_fail;
35914 }
35915 resultobj = SWIG_Py_Void();
35916 return resultobj;
35917 fail:
35918 return NULL;
35919 }
35920
35921
35922 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35923 PyObject *resultobj = 0;
35924 wxWindow *arg1 = (wxWindow *) 0 ;
35925 int arg2 ;
35926 int arg3 ;
35927 void *argp1 = 0 ;
35928 int res1 = 0 ;
35929 int val2 ;
35930 int ecode2 = 0 ;
35931 int val3 ;
35932 int ecode3 = 0 ;
35933 PyObject * obj0 = 0 ;
35934 PyObject * obj1 = 0 ;
35935 PyObject * obj2 = 0 ;
35936 char * kwnames[] = {
35937 (char *) "self",(char *) "w",(char *) "h", NULL
35938 };
35939
35940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35942 if (!SWIG_IsOK(res1)) {
35943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35944 }
35945 arg1 = reinterpret_cast< wxWindow * >(argp1);
35946 ecode2 = SWIG_AsVal_int(obj1, &val2);
35947 if (!SWIG_IsOK(ecode2)) {
35948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35949 }
35950 arg2 = static_cast< int >(val2);
35951 ecode3 = SWIG_AsVal_int(obj2, &val3);
35952 if (!SWIG_IsOK(ecode3)) {
35953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35954 }
35955 arg3 = static_cast< int >(val3);
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 (arg1)->SetVirtualSize(arg2,arg3);
35959 wxPyEndAllowThreads(__tstate);
35960 if (PyErr_Occurred()) SWIG_fail;
35961 }
35962 resultobj = SWIG_Py_Void();
35963 return resultobj;
35964 fail:
35965 return NULL;
35966 }
35967
35968
35969 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35970 PyObject *resultobj = 0;
35971 wxWindow *arg1 = (wxWindow *) 0 ;
35972 wxSize result;
35973 void *argp1 = 0 ;
35974 int res1 = 0 ;
35975 PyObject *swig_obj[1] ;
35976
35977 if (!args) SWIG_fail;
35978 swig_obj[0] = args;
35979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35980 if (!SWIG_IsOK(res1)) {
35981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35982 }
35983 arg1 = reinterpret_cast< wxWindow * >(argp1);
35984 {
35985 PyThreadState* __tstate = wxPyBeginAllowThreads();
35986 result = ((wxWindow const *)arg1)->GetVirtualSize();
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35998 PyObject *resultobj = 0;
35999 wxWindow *arg1 = (wxWindow *) 0 ;
36000 int *arg2 = (int *) 0 ;
36001 int *arg3 = (int *) 0 ;
36002 void *argp1 = 0 ;
36003 int res1 = 0 ;
36004 int temp2 ;
36005 int res2 = SWIG_TMPOBJ ;
36006 int temp3 ;
36007 int res3 = SWIG_TMPOBJ ;
36008 PyObject *swig_obj[1] ;
36009
36010 arg2 = &temp2;
36011 arg3 = &temp3;
36012 if (!args) SWIG_fail;
36013 swig_obj[0] = args;
36014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36015 if (!SWIG_IsOK(res1)) {
36016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
36017 }
36018 arg1 = reinterpret_cast< wxWindow * >(argp1);
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 resultobj = SWIG_Py_Void();
36026 if (SWIG_IsTmpObj(res2)) {
36027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36028 } else {
36029 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36031 }
36032 if (SWIG_IsTmpObj(res3)) {
36033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36034 } else {
36035 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36037 }
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36045 PyObject *resultobj = 0;
36046 wxWindow *arg1 = (wxWindow *) 0 ;
36047 wxSize result;
36048 void *argp1 = 0 ;
36049 int res1 = 0 ;
36050 PyObject *swig_obj[1] ;
36051
36052 if (!args) SWIG_fail;
36053 swig_obj[0] = args;
36054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36055 if (!SWIG_IsOK(res1)) {
36056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36057 }
36058 arg1 = reinterpret_cast< wxWindow * >(argp1);
36059 {
36060 PyThreadState* __tstate = wxPyBeginAllowThreads();
36061 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
36062 wxPyEndAllowThreads(__tstate);
36063 if (PyErr_Occurred()) SWIG_fail;
36064 }
36065 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36066 return resultobj;
36067 fail:
36068 return NULL;
36069 }
36070
36071
36072 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36073 PyObject *resultobj = 0;
36074 wxWindow *arg1 = (wxWindow *) 0 ;
36075 wxSize result;
36076 void *argp1 = 0 ;
36077 int res1 = 0 ;
36078 PyObject *swig_obj[1] ;
36079
36080 if (!args) SWIG_fail;
36081 swig_obj[0] = args;
36082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36083 if (!SWIG_IsOK(res1)) {
36084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36085 }
36086 arg1 = reinterpret_cast< wxWindow * >(argp1);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36101 PyObject *resultobj = 0;
36102 wxWindow *arg1 = (wxWindow *) 0 ;
36103 bool arg2 = (bool) true ;
36104 bool result;
36105 void *argp1 = 0 ;
36106 int res1 = 0 ;
36107 bool val2 ;
36108 int ecode2 = 0 ;
36109 PyObject * obj0 = 0 ;
36110 PyObject * obj1 = 0 ;
36111 char * kwnames[] = {
36112 (char *) "self",(char *) "show", NULL
36113 };
36114
36115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
36116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36117 if (!SWIG_IsOK(res1)) {
36118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
36119 }
36120 arg1 = reinterpret_cast< wxWindow * >(argp1);
36121 if (obj1) {
36122 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36123 if (!SWIG_IsOK(ecode2)) {
36124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
36125 }
36126 arg2 = static_cast< bool >(val2);
36127 }
36128 {
36129 PyThreadState* __tstate = wxPyBeginAllowThreads();
36130 result = (bool)(arg1)->Show(arg2);
36131 wxPyEndAllowThreads(__tstate);
36132 if (PyErr_Occurred()) SWIG_fail;
36133 }
36134 {
36135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36136 }
36137 return resultobj;
36138 fail:
36139 return NULL;
36140 }
36141
36142
36143 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36144 PyObject *resultobj = 0;
36145 wxWindow *arg1 = (wxWindow *) 0 ;
36146 bool result;
36147 void *argp1 = 0 ;
36148 int res1 = 0 ;
36149 PyObject *swig_obj[1] ;
36150
36151 if (!args) SWIG_fail;
36152 swig_obj[0] = args;
36153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36154 if (!SWIG_IsOK(res1)) {
36155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
36156 }
36157 arg1 = reinterpret_cast< wxWindow * >(argp1);
36158 {
36159 PyThreadState* __tstate = wxPyBeginAllowThreads();
36160 result = (bool)(arg1)->Hide();
36161 wxPyEndAllowThreads(__tstate);
36162 if (PyErr_Occurred()) SWIG_fail;
36163 }
36164 {
36165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36166 }
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36174 PyObject *resultobj = 0;
36175 wxWindow *arg1 = (wxWindow *) 0 ;
36176 bool arg2 = (bool) true ;
36177 bool result;
36178 void *argp1 = 0 ;
36179 int res1 = 0 ;
36180 bool val2 ;
36181 int ecode2 = 0 ;
36182 PyObject * obj0 = 0 ;
36183 PyObject * obj1 = 0 ;
36184 char * kwnames[] = {
36185 (char *) "self",(char *) "enable", NULL
36186 };
36187
36188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
36189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36190 if (!SWIG_IsOK(res1)) {
36191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
36192 }
36193 arg1 = reinterpret_cast< wxWindow * >(argp1);
36194 if (obj1) {
36195 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36196 if (!SWIG_IsOK(ecode2)) {
36197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
36198 }
36199 arg2 = static_cast< bool >(val2);
36200 }
36201 {
36202 PyThreadState* __tstate = wxPyBeginAllowThreads();
36203 result = (bool)(arg1)->Enable(arg2);
36204 wxPyEndAllowThreads(__tstate);
36205 if (PyErr_Occurred()) SWIG_fail;
36206 }
36207 {
36208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36209 }
36210 return resultobj;
36211 fail:
36212 return NULL;
36213 }
36214
36215
36216 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36217 PyObject *resultobj = 0;
36218 wxWindow *arg1 = (wxWindow *) 0 ;
36219 bool result;
36220 void *argp1 = 0 ;
36221 int res1 = 0 ;
36222 PyObject *swig_obj[1] ;
36223
36224 if (!args) SWIG_fail;
36225 swig_obj[0] = args;
36226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36227 if (!SWIG_IsOK(res1)) {
36228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
36229 }
36230 arg1 = reinterpret_cast< wxWindow * >(argp1);
36231 {
36232 PyThreadState* __tstate = wxPyBeginAllowThreads();
36233 result = (bool)(arg1)->Disable();
36234 wxPyEndAllowThreads(__tstate);
36235 if (PyErr_Occurred()) SWIG_fail;
36236 }
36237 {
36238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36239 }
36240 return resultobj;
36241 fail:
36242 return NULL;
36243 }
36244
36245
36246 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36247 PyObject *resultobj = 0;
36248 wxWindow *arg1 = (wxWindow *) 0 ;
36249 bool result;
36250 void *argp1 = 0 ;
36251 int res1 = 0 ;
36252 PyObject *swig_obj[1] ;
36253
36254 if (!args) SWIG_fail;
36255 swig_obj[0] = args;
36256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36257 if (!SWIG_IsOK(res1)) {
36258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
36259 }
36260 arg1 = reinterpret_cast< wxWindow * >(argp1);
36261 {
36262 PyThreadState* __tstate = wxPyBeginAllowThreads();
36263 result = (bool)((wxWindow const *)arg1)->IsShown();
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 {
36268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36269 }
36270 return resultobj;
36271 fail:
36272 return NULL;
36273 }
36274
36275
36276 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36277 PyObject *resultobj = 0;
36278 wxWindow *arg1 = (wxWindow *) 0 ;
36279 bool result;
36280 void *argp1 = 0 ;
36281 int res1 = 0 ;
36282 PyObject *swig_obj[1] ;
36283
36284 if (!args) SWIG_fail;
36285 swig_obj[0] = args;
36286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36287 if (!SWIG_IsOK(res1)) {
36288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36289 }
36290 arg1 = reinterpret_cast< wxWindow * >(argp1);
36291 {
36292 PyThreadState* __tstate = wxPyBeginAllowThreads();
36293 result = (bool)((wxWindow const *)arg1)->IsEnabled();
36294 wxPyEndAllowThreads(__tstate);
36295 if (PyErr_Occurred()) SWIG_fail;
36296 }
36297 {
36298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36299 }
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36307 PyObject *resultobj = 0;
36308 wxWindow *arg1 = (wxWindow *) 0 ;
36309 bool result;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 PyObject *swig_obj[1] ;
36313
36314 if (!args) SWIG_fail;
36315 swig_obj[0] = args;
36316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36317 if (!SWIG_IsOK(res1)) {
36318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36319 }
36320 arg1 = reinterpret_cast< wxWindow * >(argp1);
36321 {
36322 PyThreadState* __tstate = wxPyBeginAllowThreads();
36323 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
36324 wxPyEndAllowThreads(__tstate);
36325 if (PyErr_Occurred()) SWIG_fail;
36326 }
36327 {
36328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36329 }
36330 return resultobj;
36331 fail:
36332 return NULL;
36333 }
36334
36335
36336 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36337 PyObject *resultobj = 0;
36338 wxWindow *arg1 = (wxWindow *) 0 ;
36339 bool result;
36340 void *argp1 = 0 ;
36341 int res1 = 0 ;
36342 PyObject *swig_obj[1] ;
36343
36344 if (!args) SWIG_fail;
36345 swig_obj[0] = args;
36346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36347 if (!SWIG_IsOK(res1)) {
36348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36349 }
36350 arg1 = reinterpret_cast< wxWindow * >(argp1);
36351 {
36352 PyThreadState* __tstate = wxPyBeginAllowThreads();
36353 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
36354 wxPyEndAllowThreads(__tstate);
36355 if (PyErr_Occurred()) SWIG_fail;
36356 }
36357 {
36358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36359 }
36360 return resultobj;
36361 fail:
36362 return NULL;
36363 }
36364
36365
36366 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36367 PyObject *resultobj = 0;
36368 wxWindow *arg1 = (wxWindow *) 0 ;
36369 long arg2 ;
36370 void *argp1 = 0 ;
36371 int res1 = 0 ;
36372 long val2 ;
36373 int ecode2 = 0 ;
36374 PyObject * obj0 = 0 ;
36375 PyObject * obj1 = 0 ;
36376 char * kwnames[] = {
36377 (char *) "self",(char *) "style", NULL
36378 };
36379
36380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36382 if (!SWIG_IsOK(res1)) {
36383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
36384 }
36385 arg1 = reinterpret_cast< wxWindow * >(argp1);
36386 ecode2 = SWIG_AsVal_long(obj1, &val2);
36387 if (!SWIG_IsOK(ecode2)) {
36388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
36389 }
36390 arg2 = static_cast< long >(val2);
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 (arg1)->SetWindowStyleFlag(arg2);
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 resultobj = SWIG_Py_Void();
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36405 PyObject *resultobj = 0;
36406 wxWindow *arg1 = (wxWindow *) 0 ;
36407 long result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 PyObject *swig_obj[1] ;
36411
36412 if (!args) SWIG_fail;
36413 swig_obj[0] = args;
36414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36415 if (!SWIG_IsOK(res1)) {
36416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36417 }
36418 arg1 = reinterpret_cast< wxWindow * >(argp1);
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
36422 wxPyEndAllowThreads(__tstate);
36423 if (PyErr_Occurred()) SWIG_fail;
36424 }
36425 resultobj = SWIG_From_long(static_cast< long >(result));
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36433 PyObject *resultobj = 0;
36434 wxWindow *arg1 = (wxWindow *) 0 ;
36435 int arg2 ;
36436 bool result;
36437 void *argp1 = 0 ;
36438 int res1 = 0 ;
36439 int val2 ;
36440 int ecode2 = 0 ;
36441 PyObject * obj0 = 0 ;
36442 PyObject * obj1 = 0 ;
36443 char * kwnames[] = {
36444 (char *) "self",(char *) "flag", NULL
36445 };
36446
36447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36449 if (!SWIG_IsOK(res1)) {
36450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36451 }
36452 arg1 = reinterpret_cast< wxWindow * >(argp1);
36453 ecode2 = SWIG_AsVal_int(obj1, &val2);
36454 if (!SWIG_IsOK(ecode2)) {
36455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
36456 }
36457 arg2 = static_cast< int >(val2);
36458 {
36459 PyThreadState* __tstate = wxPyBeginAllowThreads();
36460 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
36461 wxPyEndAllowThreads(__tstate);
36462 if (PyErr_Occurred()) SWIG_fail;
36463 }
36464 {
36465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36466 }
36467 return resultobj;
36468 fail:
36469 return NULL;
36470 }
36471
36472
36473 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36474 PyObject *resultobj = 0;
36475 wxWindow *arg1 = (wxWindow *) 0 ;
36476 bool result;
36477 void *argp1 = 0 ;
36478 int res1 = 0 ;
36479 PyObject *swig_obj[1] ;
36480
36481 if (!args) SWIG_fail;
36482 swig_obj[0] = args;
36483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36484 if (!SWIG_IsOK(res1)) {
36485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36486 }
36487 arg1 = reinterpret_cast< wxWindow * >(argp1);
36488 {
36489 PyThreadState* __tstate = wxPyBeginAllowThreads();
36490 result = (bool)((wxWindow const *)arg1)->IsRetained();
36491 wxPyEndAllowThreads(__tstate);
36492 if (PyErr_Occurred()) SWIG_fail;
36493 }
36494 {
36495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36496 }
36497 return resultobj;
36498 fail:
36499 return NULL;
36500 }
36501
36502
36503 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36504 PyObject *resultobj = 0;
36505 wxWindow *arg1 = (wxWindow *) 0 ;
36506 int arg2 ;
36507 bool result;
36508 void *argp1 = 0 ;
36509 int res1 = 0 ;
36510 int val2 ;
36511 int ecode2 = 0 ;
36512 PyObject * obj0 = 0 ;
36513 PyObject * obj1 = 0 ;
36514 char * kwnames[] = {
36515 (char *) "self",(char *) "flag", NULL
36516 };
36517
36518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36520 if (!SWIG_IsOK(res1)) {
36521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36522 }
36523 arg1 = reinterpret_cast< wxWindow * >(argp1);
36524 ecode2 = SWIG_AsVal_int(obj1, &val2);
36525 if (!SWIG_IsOK(ecode2)) {
36526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36527 }
36528 arg2 = static_cast< int >(val2);
36529 {
36530 PyThreadState* __tstate = wxPyBeginAllowThreads();
36531 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36532 wxPyEndAllowThreads(__tstate);
36533 if (PyErr_Occurred()) SWIG_fail;
36534 }
36535 {
36536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36537 }
36538 return resultobj;
36539 fail:
36540 return NULL;
36541 }
36542
36543
36544 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36545 PyObject *resultobj = 0;
36546 wxWindow *arg1 = (wxWindow *) 0 ;
36547 long arg2 ;
36548 void *argp1 = 0 ;
36549 int res1 = 0 ;
36550 long val2 ;
36551 int ecode2 = 0 ;
36552 PyObject * obj0 = 0 ;
36553 PyObject * obj1 = 0 ;
36554 char * kwnames[] = {
36555 (char *) "self",(char *) "exStyle", NULL
36556 };
36557
36558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36560 if (!SWIG_IsOK(res1)) {
36561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36562 }
36563 arg1 = reinterpret_cast< wxWindow * >(argp1);
36564 ecode2 = SWIG_AsVal_long(obj1, &val2);
36565 if (!SWIG_IsOK(ecode2)) {
36566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36567 }
36568 arg2 = static_cast< long >(val2);
36569 {
36570 PyThreadState* __tstate = wxPyBeginAllowThreads();
36571 (arg1)->SetExtraStyle(arg2);
36572 wxPyEndAllowThreads(__tstate);
36573 if (PyErr_Occurred()) SWIG_fail;
36574 }
36575 resultobj = SWIG_Py_Void();
36576 return resultobj;
36577 fail:
36578 return NULL;
36579 }
36580
36581
36582 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36583 PyObject *resultobj = 0;
36584 wxWindow *arg1 = (wxWindow *) 0 ;
36585 long result;
36586 void *argp1 = 0 ;
36587 int res1 = 0 ;
36588 PyObject *swig_obj[1] ;
36589
36590 if (!args) SWIG_fail;
36591 swig_obj[0] = args;
36592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36593 if (!SWIG_IsOK(res1)) {
36594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36595 }
36596 arg1 = reinterpret_cast< wxWindow * >(argp1);
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36600 wxPyEndAllowThreads(__tstate);
36601 if (PyErr_Occurred()) SWIG_fail;
36602 }
36603 resultobj = SWIG_From_long(static_cast< long >(result));
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 SWIGINTERN PyObject *_wrap_Window_HasExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36611 PyObject *resultobj = 0;
36612 wxWindow *arg1 = (wxWindow *) 0 ;
36613 int arg2 ;
36614 bool result;
36615 void *argp1 = 0 ;
36616 int res1 = 0 ;
36617 int val2 ;
36618 int ecode2 = 0 ;
36619 PyObject * obj0 = 0 ;
36620 PyObject * obj1 = 0 ;
36621 char * kwnames[] = {
36622 (char *) "self",(char *) "exFlag", NULL
36623 };
36624
36625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36627 if (!SWIG_IsOK(res1)) {
36628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36629 }
36630 arg1 = reinterpret_cast< wxWindow * >(argp1);
36631 ecode2 = SWIG_AsVal_int(obj1, &val2);
36632 if (!SWIG_IsOK(ecode2)) {
36633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasExtraStyle" "', expected argument " "2"" of type '" "int""'");
36634 }
36635 arg2 = static_cast< int >(val2);
36636 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 result = (bool)((wxWindow const *)arg1)->HasExtraStyle(arg2);
36639 wxPyEndAllowThreads(__tstate);
36640 if (PyErr_Occurred()) SWIG_fail;
36641 }
36642 {
36643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36644 }
36645 return resultobj;
36646 fail:
36647 return NULL;
36648 }
36649
36650
36651 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36652 PyObject *resultobj = 0;
36653 wxWindow *arg1 = (wxWindow *) 0 ;
36654 bool arg2 = (bool) true ;
36655 void *argp1 = 0 ;
36656 int res1 = 0 ;
36657 bool val2 ;
36658 int ecode2 = 0 ;
36659 PyObject * obj0 = 0 ;
36660 PyObject * obj1 = 0 ;
36661 char * kwnames[] = {
36662 (char *) "self",(char *) "modal", NULL
36663 };
36664
36665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36667 if (!SWIG_IsOK(res1)) {
36668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36669 }
36670 arg1 = reinterpret_cast< wxWindow * >(argp1);
36671 if (obj1) {
36672 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36673 if (!SWIG_IsOK(ecode2)) {
36674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36675 }
36676 arg2 = static_cast< bool >(val2);
36677 }
36678 {
36679 PyThreadState* __tstate = wxPyBeginAllowThreads();
36680 (arg1)->MakeModal(arg2);
36681 wxPyEndAllowThreads(__tstate);
36682 if (PyErr_Occurred()) SWIG_fail;
36683 }
36684 resultobj = SWIG_Py_Void();
36685 return resultobj;
36686 fail:
36687 return NULL;
36688 }
36689
36690
36691 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36692 PyObject *resultobj = 0;
36693 wxWindow *arg1 = (wxWindow *) 0 ;
36694 bool arg2 ;
36695 void *argp1 = 0 ;
36696 int res1 = 0 ;
36697 bool val2 ;
36698 int ecode2 = 0 ;
36699 PyObject * obj0 = 0 ;
36700 PyObject * obj1 = 0 ;
36701 char * kwnames[] = {
36702 (char *) "self",(char *) "enableTheme", NULL
36703 };
36704
36705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36707 if (!SWIG_IsOK(res1)) {
36708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36709 }
36710 arg1 = reinterpret_cast< wxWindow * >(argp1);
36711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36712 if (!SWIG_IsOK(ecode2)) {
36713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36714 }
36715 arg2 = static_cast< bool >(val2);
36716 {
36717 PyThreadState* __tstate = wxPyBeginAllowThreads();
36718 (arg1)->SetThemeEnabled(arg2);
36719 wxPyEndAllowThreads(__tstate);
36720 if (PyErr_Occurred()) SWIG_fail;
36721 }
36722 resultobj = SWIG_Py_Void();
36723 return resultobj;
36724 fail:
36725 return NULL;
36726 }
36727
36728
36729 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36730 PyObject *resultobj = 0;
36731 wxWindow *arg1 = (wxWindow *) 0 ;
36732 bool result;
36733 void *argp1 = 0 ;
36734 int res1 = 0 ;
36735 PyObject *swig_obj[1] ;
36736
36737 if (!args) SWIG_fail;
36738 swig_obj[0] = args;
36739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36740 if (!SWIG_IsOK(res1)) {
36741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36742 }
36743 arg1 = reinterpret_cast< wxWindow * >(argp1);
36744 {
36745 PyThreadState* __tstate = wxPyBeginAllowThreads();
36746 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36747 wxPyEndAllowThreads(__tstate);
36748 if (PyErr_Occurred()) SWIG_fail;
36749 }
36750 {
36751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36752 }
36753 return resultobj;
36754 fail:
36755 return NULL;
36756 }
36757
36758
36759 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36760 PyObject *resultobj = 0;
36761 wxWindow *arg1 = (wxWindow *) 0 ;
36762 void *argp1 = 0 ;
36763 int res1 = 0 ;
36764 PyObject *swig_obj[1] ;
36765
36766 if (!args) SWIG_fail;
36767 swig_obj[0] = args;
36768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36769 if (!SWIG_IsOK(res1)) {
36770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36771 }
36772 arg1 = reinterpret_cast< wxWindow * >(argp1);
36773 {
36774 PyThreadState* __tstate = wxPyBeginAllowThreads();
36775 (arg1)->SetFocus();
36776 wxPyEndAllowThreads(__tstate);
36777 if (PyErr_Occurred()) SWIG_fail;
36778 }
36779 resultobj = SWIG_Py_Void();
36780 return resultobj;
36781 fail:
36782 return NULL;
36783 }
36784
36785
36786 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36787 PyObject *resultobj = 0;
36788 wxWindow *arg1 = (wxWindow *) 0 ;
36789 void *argp1 = 0 ;
36790 int res1 = 0 ;
36791 PyObject *swig_obj[1] ;
36792
36793 if (!args) SWIG_fail;
36794 swig_obj[0] = args;
36795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36796 if (!SWIG_IsOK(res1)) {
36797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36798 }
36799 arg1 = reinterpret_cast< wxWindow * >(argp1);
36800 {
36801 PyThreadState* __tstate = wxPyBeginAllowThreads();
36802 (arg1)->SetFocusFromKbd();
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_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36814 PyObject *resultobj = 0;
36815 wxWindow *result = 0 ;
36816
36817 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36818 {
36819 if (!wxPyCheckForApp()) SWIG_fail;
36820 PyThreadState* __tstate = wxPyBeginAllowThreads();
36821 result = (wxWindow *)wxWindow::FindFocus();
36822 wxPyEndAllowThreads(__tstate);
36823 if (PyErr_Occurred()) SWIG_fail;
36824 }
36825 {
36826 resultobj = wxPyMake_wxObject(result, 0);
36827 }
36828 return resultobj;
36829 fail:
36830 return NULL;
36831 }
36832
36833
36834 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36835 PyObject *resultobj = 0;
36836 wxWindow *arg1 = (wxWindow *) 0 ;
36837 bool result;
36838 void *argp1 = 0 ;
36839 int res1 = 0 ;
36840 PyObject *swig_obj[1] ;
36841
36842 if (!args) SWIG_fail;
36843 swig_obj[0] = args;
36844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36845 if (!SWIG_IsOK(res1)) {
36846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36847 }
36848 arg1 = reinterpret_cast< wxWindow * >(argp1);
36849 {
36850 PyThreadState* __tstate = wxPyBeginAllowThreads();
36851 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36852 wxPyEndAllowThreads(__tstate);
36853 if (PyErr_Occurred()) SWIG_fail;
36854 }
36855 {
36856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36857 }
36858 return resultobj;
36859 fail:
36860 return NULL;
36861 }
36862
36863
36864 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36865 PyObject *resultobj = 0;
36866 wxWindow *arg1 = (wxWindow *) 0 ;
36867 bool result;
36868 void *argp1 = 0 ;
36869 int res1 = 0 ;
36870 PyObject *swig_obj[1] ;
36871
36872 if (!args) SWIG_fail;
36873 swig_obj[0] = args;
36874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36875 if (!SWIG_IsOK(res1)) {
36876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36877 }
36878 arg1 = reinterpret_cast< wxWindow * >(argp1);
36879 {
36880 PyThreadState* __tstate = wxPyBeginAllowThreads();
36881 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36882 wxPyEndAllowThreads(__tstate);
36883 if (PyErr_Occurred()) SWIG_fail;
36884 }
36885 {
36886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36887 }
36888 return resultobj;
36889 fail:
36890 return NULL;
36891 }
36892
36893
36894 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36895 PyObject *resultobj = 0;
36896 wxWindow *arg1 = (wxWindow *) 0 ;
36897 bool result;
36898 void *argp1 = 0 ;
36899 int res1 = 0 ;
36900 PyObject *swig_obj[1] ;
36901
36902 if (!args) SWIG_fail;
36903 swig_obj[0] = args;
36904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36905 if (!SWIG_IsOK(res1)) {
36906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36907 }
36908 arg1 = reinterpret_cast< wxWindow * >(argp1);
36909 {
36910 PyThreadState* __tstate = wxPyBeginAllowThreads();
36911 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36912 wxPyEndAllowThreads(__tstate);
36913 if (PyErr_Occurred()) SWIG_fail;
36914 }
36915 {
36916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36917 }
36918 return resultobj;
36919 fail:
36920 return NULL;
36921 }
36922
36923
36924 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36925 PyObject *resultobj = 0;
36926 wxWindow *arg1 = (wxWindow *) 0 ;
36927 bool result;
36928 void *argp1 = 0 ;
36929 int res1 = 0 ;
36930 PyObject *swig_obj[1] ;
36931
36932 if (!args) SWIG_fail;
36933 swig_obj[0] = args;
36934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36935 if (!SWIG_IsOK(res1)) {
36936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36937 }
36938 arg1 = reinterpret_cast< wxWindow * >(argp1);
36939 {
36940 PyThreadState* __tstate = wxPyBeginAllowThreads();
36941 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 {
36946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36947 }
36948 return resultobj;
36949 fail:
36950 return NULL;
36951 }
36952
36953
36954 SWIGINTERN PyObject *_wrap_Window_SetCanFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36955 PyObject *resultobj = 0;
36956 wxWindow *arg1 = (wxWindow *) 0 ;
36957 bool arg2 ;
36958 void *argp1 = 0 ;
36959 int res1 = 0 ;
36960 bool val2 ;
36961 int ecode2 = 0 ;
36962 PyObject * obj0 = 0 ;
36963 PyObject * obj1 = 0 ;
36964 char * kwnames[] = {
36965 (char *) "self",(char *) "canFocus", NULL
36966 };
36967
36968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCanFocus",kwnames,&obj0,&obj1)) SWIG_fail;
36969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36970 if (!SWIG_IsOK(res1)) {
36971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCanFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36972 }
36973 arg1 = reinterpret_cast< wxWindow * >(argp1);
36974 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36975 if (!SWIG_IsOK(ecode2)) {
36976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetCanFocus" "', expected argument " "2"" of type '" "bool""'");
36977 }
36978 arg2 = static_cast< bool >(val2);
36979 {
36980 PyThreadState* __tstate = wxPyBeginAllowThreads();
36981 (arg1)->SetCanFocus(arg2);
36982 wxPyEndAllowThreads(__tstate);
36983 if (PyErr_Occurred()) SWIG_fail;
36984 }
36985 resultobj = SWIG_Py_Void();
36986 return resultobj;
36987 fail:
36988 return NULL;
36989 }
36990
36991
36992 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36993 PyObject *resultobj = 0;
36994 wxWindow *arg1 = (wxWindow *) 0 ;
36995 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36996 bool result;
36997 void *argp1 = 0 ;
36998 int res1 = 0 ;
36999 int val2 ;
37000 int ecode2 = 0 ;
37001 PyObject * obj0 = 0 ;
37002 PyObject * obj1 = 0 ;
37003 char * kwnames[] = {
37004 (char *) "self",(char *) "flags", NULL
37005 };
37006
37007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
37008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37009 if (!SWIG_IsOK(res1)) {
37010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
37011 }
37012 arg1 = reinterpret_cast< wxWindow * >(argp1);
37013 if (obj1) {
37014 ecode2 = SWIG_AsVal_int(obj1, &val2);
37015 if (!SWIG_IsOK(ecode2)) {
37016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
37017 }
37018 arg2 = static_cast< int >(val2);
37019 }
37020 {
37021 PyThreadState* __tstate = wxPyBeginAllowThreads();
37022 result = (bool)(arg1)->NavigateIn(arg2);
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 {
37027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37028 }
37029 return resultobj;
37030 fail:
37031 return NULL;
37032 }
37033
37034
37035 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37036 PyObject *resultobj = 0;
37037 wxWindow *arg1 = (wxWindow *) 0 ;
37038 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
37039 bool result;
37040 void *argp1 = 0 ;
37041 int res1 = 0 ;
37042 int val2 ;
37043 int ecode2 = 0 ;
37044 PyObject * obj0 = 0 ;
37045 PyObject * obj1 = 0 ;
37046 char * kwnames[] = {
37047 (char *) "self",(char *) "flags", NULL
37048 };
37049
37050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
37051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37052 if (!SWIG_IsOK(res1)) {
37053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
37054 }
37055 arg1 = reinterpret_cast< wxWindow * >(argp1);
37056 if (obj1) {
37057 ecode2 = SWIG_AsVal_int(obj1, &val2);
37058 if (!SWIG_IsOK(ecode2)) {
37059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
37060 }
37061 arg2 = static_cast< int >(val2);
37062 }
37063 {
37064 PyThreadState* __tstate = wxPyBeginAllowThreads();
37065 result = (bool)(arg1)->Navigate(arg2);
37066 wxPyEndAllowThreads(__tstate);
37067 if (PyErr_Occurred()) SWIG_fail;
37068 }
37069 {
37070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37071 }
37072 return resultobj;
37073 fail:
37074 return NULL;
37075 }
37076
37077
37078 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37079 PyObject *resultobj = 0;
37080 wxWindow *arg1 = (wxWindow *) 0 ;
37081 wxWindow *arg2 = (wxWindow *) 0 ;
37082 void *argp1 = 0 ;
37083 int res1 = 0 ;
37084 void *argp2 = 0 ;
37085 int res2 = 0 ;
37086 PyObject * obj0 = 0 ;
37087 PyObject * obj1 = 0 ;
37088 char * kwnames[] = {
37089 (char *) "self",(char *) "win", NULL
37090 };
37091
37092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37094 if (!SWIG_IsOK(res1)) {
37095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37096 }
37097 arg1 = reinterpret_cast< wxWindow * >(argp1);
37098 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37099 if (!SWIG_IsOK(res2)) {
37100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37101 }
37102 arg2 = reinterpret_cast< wxWindow * >(argp2);
37103 {
37104 PyThreadState* __tstate = wxPyBeginAllowThreads();
37105 (arg1)->MoveAfterInTabOrder(arg2);
37106 wxPyEndAllowThreads(__tstate);
37107 if (PyErr_Occurred()) SWIG_fail;
37108 }
37109 resultobj = SWIG_Py_Void();
37110 return resultobj;
37111 fail:
37112 return NULL;
37113 }
37114
37115
37116 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37117 PyObject *resultobj = 0;
37118 wxWindow *arg1 = (wxWindow *) 0 ;
37119 wxWindow *arg2 = (wxWindow *) 0 ;
37120 void *argp1 = 0 ;
37121 int res1 = 0 ;
37122 void *argp2 = 0 ;
37123 int res2 = 0 ;
37124 PyObject * obj0 = 0 ;
37125 PyObject * obj1 = 0 ;
37126 char * kwnames[] = {
37127 (char *) "self",(char *) "win", NULL
37128 };
37129
37130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37132 if (!SWIG_IsOK(res1)) {
37133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37134 }
37135 arg1 = reinterpret_cast< wxWindow * >(argp1);
37136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37137 if (!SWIG_IsOK(res2)) {
37138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37139 }
37140 arg2 = reinterpret_cast< wxWindow * >(argp2);
37141 {
37142 PyThreadState* __tstate = wxPyBeginAllowThreads();
37143 (arg1)->MoveBeforeInTabOrder(arg2);
37144 wxPyEndAllowThreads(__tstate);
37145 if (PyErr_Occurred()) SWIG_fail;
37146 }
37147 resultobj = SWIG_Py_Void();
37148 return resultobj;
37149 fail:
37150 return NULL;
37151 }
37152
37153
37154 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37155 PyObject *resultobj = 0;
37156 wxWindow *arg1 = (wxWindow *) 0 ;
37157 PyObject *result = 0 ;
37158 void *argp1 = 0 ;
37159 int res1 = 0 ;
37160 PyObject *swig_obj[1] ;
37161
37162 if (!args) SWIG_fail;
37163 swig_obj[0] = args;
37164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37165 if (!SWIG_IsOK(res1)) {
37166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
37167 }
37168 arg1 = reinterpret_cast< wxWindow * >(argp1);
37169 {
37170 PyThreadState* __tstate = wxPyBeginAllowThreads();
37171 result = (PyObject *)wxWindow_GetChildren(arg1);
37172 wxPyEndAllowThreads(__tstate);
37173 if (PyErr_Occurred()) SWIG_fail;
37174 }
37175 resultobj = result;
37176 return resultobj;
37177 fail:
37178 return NULL;
37179 }
37180
37181
37182 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37183 PyObject *resultobj = 0;
37184 wxWindow *arg1 = (wxWindow *) 0 ;
37185 wxWindow *result = 0 ;
37186 void *argp1 = 0 ;
37187 int res1 = 0 ;
37188 PyObject *swig_obj[1] ;
37189
37190 if (!args) SWIG_fail;
37191 swig_obj[0] = args;
37192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37193 if (!SWIG_IsOK(res1)) {
37194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37195 }
37196 arg1 = reinterpret_cast< wxWindow * >(argp1);
37197 {
37198 PyThreadState* __tstate = wxPyBeginAllowThreads();
37199 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
37200 wxPyEndAllowThreads(__tstate);
37201 if (PyErr_Occurred()) SWIG_fail;
37202 }
37203 {
37204 resultobj = wxPyMake_wxObject(result, 0);
37205 }
37206 return resultobj;
37207 fail:
37208 return NULL;
37209 }
37210
37211
37212 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37213 PyObject *resultobj = 0;
37214 wxWindow *arg1 = (wxWindow *) 0 ;
37215 wxWindow *result = 0 ;
37216 void *argp1 = 0 ;
37217 int res1 = 0 ;
37218 PyObject *swig_obj[1] ;
37219
37220 if (!args) SWIG_fail;
37221 swig_obj[0] = args;
37222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37223 if (!SWIG_IsOK(res1)) {
37224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37225 }
37226 arg1 = reinterpret_cast< wxWindow * >(argp1);
37227 {
37228 PyThreadState* __tstate = wxPyBeginAllowThreads();
37229 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
37230 wxPyEndAllowThreads(__tstate);
37231 if (PyErr_Occurred()) SWIG_fail;
37232 }
37233 {
37234 resultobj = wxPyMake_wxObject(result, 0);
37235 }
37236 return resultobj;
37237 fail:
37238 return NULL;
37239 }
37240
37241
37242 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37243 PyObject *resultobj = 0;
37244 wxWindow *arg1 = (wxWindow *) 0 ;
37245 wxWindow *result = 0 ;
37246 void *argp1 = 0 ;
37247 int res1 = 0 ;
37248 PyObject *swig_obj[1] ;
37249
37250 if (!args) SWIG_fail;
37251 swig_obj[0] = args;
37252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37253 if (!SWIG_IsOK(res1)) {
37254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
37255 }
37256 arg1 = reinterpret_cast< wxWindow * >(argp1);
37257 {
37258 PyThreadState* __tstate = wxPyBeginAllowThreads();
37259 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
37260 wxPyEndAllowThreads(__tstate);
37261 if (PyErr_Occurred()) SWIG_fail;
37262 }
37263 {
37264 resultobj = wxPyMake_wxObject(result, 0);
37265 }
37266 return resultobj;
37267 fail:
37268 return NULL;
37269 }
37270
37271
37272 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37273 PyObject *resultobj = 0;
37274 wxWindow *arg1 = (wxWindow *) 0 ;
37275 bool result;
37276 void *argp1 = 0 ;
37277 int res1 = 0 ;
37278 PyObject *swig_obj[1] ;
37279
37280 if (!args) SWIG_fail;
37281 swig_obj[0] = args;
37282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37283 if (!SWIG_IsOK(res1)) {
37284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
37285 }
37286 arg1 = reinterpret_cast< wxWindow * >(argp1);
37287 {
37288 PyThreadState* __tstate = wxPyBeginAllowThreads();
37289 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
37290 wxPyEndAllowThreads(__tstate);
37291 if (PyErr_Occurred()) SWIG_fail;
37292 }
37293 {
37294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37295 }
37296 return resultobj;
37297 fail:
37298 return NULL;
37299 }
37300
37301
37302 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37303 PyObject *resultobj = 0;
37304 wxWindow *arg1 = (wxWindow *) 0 ;
37305 wxWindow *arg2 = (wxWindow *) 0 ;
37306 bool result;
37307 void *argp1 = 0 ;
37308 int res1 = 0 ;
37309 void *argp2 = 0 ;
37310 int res2 = 0 ;
37311 PyObject * obj0 = 0 ;
37312 PyObject * obj1 = 0 ;
37313 char * kwnames[] = {
37314 (char *) "self",(char *) "newParent", NULL
37315 };
37316
37317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
37318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37319 if (!SWIG_IsOK(res1)) {
37320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37321 }
37322 arg1 = reinterpret_cast< wxWindow * >(argp1);
37323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37324 if (!SWIG_IsOK(res2)) {
37325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
37326 }
37327 arg2 = reinterpret_cast< wxWindow * >(argp2);
37328 {
37329 PyThreadState* __tstate = wxPyBeginAllowThreads();
37330 result = (bool)(arg1)->Reparent(arg2);
37331 wxPyEndAllowThreads(__tstate);
37332 if (PyErr_Occurred()) SWIG_fail;
37333 }
37334 {
37335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37336 }
37337 return resultobj;
37338 fail:
37339 return NULL;
37340 }
37341
37342
37343 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37344 PyObject *resultobj = 0;
37345 wxWindow *arg1 = (wxWindow *) 0 ;
37346 wxWindow *arg2 = (wxWindow *) 0 ;
37347 void *argp1 = 0 ;
37348 int res1 = 0 ;
37349 void *argp2 = 0 ;
37350 int res2 = 0 ;
37351 PyObject * obj0 = 0 ;
37352 PyObject * obj1 = 0 ;
37353 char * kwnames[] = {
37354 (char *) "self",(char *) "child", NULL
37355 };
37356
37357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
37358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37359 if (!SWIG_IsOK(res1)) {
37360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37361 }
37362 arg1 = reinterpret_cast< wxWindow * >(argp1);
37363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37364 if (!SWIG_IsOK(res2)) {
37365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37366 }
37367 arg2 = reinterpret_cast< wxWindow * >(argp2);
37368 {
37369 PyThreadState* __tstate = wxPyBeginAllowThreads();
37370 (arg1)->AddChild(arg2);
37371 wxPyEndAllowThreads(__tstate);
37372 if (PyErr_Occurred()) SWIG_fail;
37373 }
37374 resultobj = SWIG_Py_Void();
37375 return resultobj;
37376 fail:
37377 return NULL;
37378 }
37379
37380
37381 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37382 PyObject *resultobj = 0;
37383 wxWindow *arg1 = (wxWindow *) 0 ;
37384 wxWindow *arg2 = (wxWindow *) 0 ;
37385 void *argp1 = 0 ;
37386 int res1 = 0 ;
37387 void *argp2 = 0 ;
37388 int res2 = 0 ;
37389 PyObject * obj0 = 0 ;
37390 PyObject * obj1 = 0 ;
37391 char * kwnames[] = {
37392 (char *) "self",(char *) "child", NULL
37393 };
37394
37395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
37396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37397 if (!SWIG_IsOK(res1)) {
37398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37399 }
37400 arg1 = reinterpret_cast< wxWindow * >(argp1);
37401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37402 if (!SWIG_IsOK(res2)) {
37403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37404 }
37405 arg2 = reinterpret_cast< wxWindow * >(argp2);
37406 {
37407 PyThreadState* __tstate = wxPyBeginAllowThreads();
37408 (arg1)->RemoveChild(arg2);
37409 wxPyEndAllowThreads(__tstate);
37410 if (PyErr_Occurred()) SWIG_fail;
37411 }
37412 resultobj = SWIG_Py_Void();
37413 return resultobj;
37414 fail:
37415 return NULL;
37416 }
37417
37418
37419 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37420 PyObject *resultobj = 0;
37421 wxWindow *arg1 = (wxWindow *) 0 ;
37422 bool arg2 ;
37423 void *argp1 = 0 ;
37424 int res1 = 0 ;
37425 bool val2 ;
37426 int ecode2 = 0 ;
37427 PyObject * obj0 = 0 ;
37428 PyObject * obj1 = 0 ;
37429 char * kwnames[] = {
37430 (char *) "self",(char *) "on", NULL
37431 };
37432
37433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
37434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37435 if (!SWIG_IsOK(res1)) {
37436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
37437 }
37438 arg1 = reinterpret_cast< wxWindow * >(argp1);
37439 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37440 if (!SWIG_IsOK(ecode2)) {
37441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
37442 }
37443 arg2 = static_cast< bool >(val2);
37444 {
37445 PyThreadState* __tstate = wxPyBeginAllowThreads();
37446 wxWindow_SetDoubleBuffered(arg1,arg2);
37447 wxPyEndAllowThreads(__tstate);
37448 if (PyErr_Occurred()) SWIG_fail;
37449 }
37450 resultobj = SWIG_Py_Void();
37451 return resultobj;
37452 fail:
37453 return NULL;
37454 }
37455
37456
37457 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37458 PyObject *resultobj = 0;
37459 wxWindow *arg1 = (wxWindow *) 0 ;
37460 long arg2 ;
37461 wxWindow *result = 0 ;
37462 void *argp1 = 0 ;
37463 int res1 = 0 ;
37464 long val2 ;
37465 int ecode2 = 0 ;
37466 PyObject * obj0 = 0 ;
37467 PyObject * obj1 = 0 ;
37468 char * kwnames[] = {
37469 (char *) "self",(char *) "winid", NULL
37470 };
37471
37472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37474 if (!SWIG_IsOK(res1)) {
37475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
37476 }
37477 arg1 = reinterpret_cast< wxWindow * >(argp1);
37478 ecode2 = SWIG_AsVal_long(obj1, &val2);
37479 if (!SWIG_IsOK(ecode2)) {
37480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
37481 }
37482 arg2 = static_cast< long >(val2);
37483 {
37484 PyThreadState* __tstate = wxPyBeginAllowThreads();
37485 result = (wxWindow *)(arg1)->FindWindow(arg2);
37486 wxPyEndAllowThreads(__tstate);
37487 if (PyErr_Occurred()) SWIG_fail;
37488 }
37489 {
37490 resultobj = wxPyMake_wxObject(result, 0);
37491 }
37492 return resultobj;
37493 fail:
37494 return NULL;
37495 }
37496
37497
37498 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37499 PyObject *resultobj = 0;
37500 wxWindow *arg1 = (wxWindow *) 0 ;
37501 wxString *arg2 = 0 ;
37502 wxWindow *result = 0 ;
37503 void *argp1 = 0 ;
37504 int res1 = 0 ;
37505 bool temp2 = false ;
37506 PyObject * obj0 = 0 ;
37507 PyObject * obj1 = 0 ;
37508 char * kwnames[] = {
37509 (char *) "self",(char *) "name", NULL
37510 };
37511
37512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37514 if (!SWIG_IsOK(res1)) {
37515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
37516 }
37517 arg1 = reinterpret_cast< wxWindow * >(argp1);
37518 {
37519 arg2 = wxString_in_helper(obj1);
37520 if (arg2 == NULL) SWIG_fail;
37521 temp2 = true;
37522 }
37523 {
37524 PyThreadState* __tstate = wxPyBeginAllowThreads();
37525 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
37526 wxPyEndAllowThreads(__tstate);
37527 if (PyErr_Occurred()) SWIG_fail;
37528 }
37529 {
37530 resultobj = wxPyMake_wxObject(result, 0);
37531 }
37532 {
37533 if (temp2)
37534 delete arg2;
37535 }
37536 return resultobj;
37537 fail:
37538 {
37539 if (temp2)
37540 delete arg2;
37541 }
37542 return NULL;
37543 }
37544
37545
37546 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37547 PyObject *resultobj = 0;
37548 wxWindow *arg1 = (wxWindow *) 0 ;
37549 wxEvtHandler *result = 0 ;
37550 void *argp1 = 0 ;
37551 int res1 = 0 ;
37552 PyObject *swig_obj[1] ;
37553
37554 if (!args) SWIG_fail;
37555 swig_obj[0] = args;
37556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37557 if (!SWIG_IsOK(res1)) {
37558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37559 }
37560 arg1 = reinterpret_cast< wxWindow * >(argp1);
37561 {
37562 PyThreadState* __tstate = wxPyBeginAllowThreads();
37563 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37564 wxPyEndAllowThreads(__tstate);
37565 if (PyErr_Occurred()) SWIG_fail;
37566 }
37567 {
37568 resultobj = wxPyMake_wxObject(result, 0);
37569 }
37570 return resultobj;
37571 fail:
37572 return NULL;
37573 }
37574
37575
37576 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37577 PyObject *resultobj = 0;
37578 wxWindow *arg1 = (wxWindow *) 0 ;
37579 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37580 void *argp1 = 0 ;
37581 int res1 = 0 ;
37582 void *argp2 = 0 ;
37583 int res2 = 0 ;
37584 PyObject * obj0 = 0 ;
37585 PyObject * obj1 = 0 ;
37586 char * kwnames[] = {
37587 (char *) "self",(char *) "handler", NULL
37588 };
37589
37590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37592 if (!SWIG_IsOK(res1)) {
37593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37594 }
37595 arg1 = reinterpret_cast< wxWindow * >(argp1);
37596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37597 if (!SWIG_IsOK(res2)) {
37598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37599 }
37600 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37601 {
37602 PyThreadState* __tstate = wxPyBeginAllowThreads();
37603 (arg1)->SetEventHandler(arg2);
37604 wxPyEndAllowThreads(__tstate);
37605 if (PyErr_Occurred()) SWIG_fail;
37606 }
37607 resultobj = SWIG_Py_Void();
37608 return resultobj;
37609 fail:
37610 return NULL;
37611 }
37612
37613
37614 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37615 PyObject *resultobj = 0;
37616 wxWindow *arg1 = (wxWindow *) 0 ;
37617 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37618 void *argp1 = 0 ;
37619 int res1 = 0 ;
37620 void *argp2 = 0 ;
37621 int res2 = 0 ;
37622 PyObject * obj0 = 0 ;
37623 PyObject * obj1 = 0 ;
37624 char * kwnames[] = {
37625 (char *) "self",(char *) "handler", NULL
37626 };
37627
37628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37630 if (!SWIG_IsOK(res1)) {
37631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37632 }
37633 arg1 = reinterpret_cast< wxWindow * >(argp1);
37634 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37635 if (!SWIG_IsOK(res2)) {
37636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37637 }
37638 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37639 {
37640 PyThreadState* __tstate = wxPyBeginAllowThreads();
37641 (arg1)->PushEventHandler(arg2);
37642 wxPyEndAllowThreads(__tstate);
37643 if (PyErr_Occurred()) SWIG_fail;
37644 }
37645 resultobj = SWIG_Py_Void();
37646 return resultobj;
37647 fail:
37648 return NULL;
37649 }
37650
37651
37652 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37653 PyObject *resultobj = 0;
37654 wxWindow *arg1 = (wxWindow *) 0 ;
37655 bool arg2 = (bool) false ;
37656 wxEvtHandler *result = 0 ;
37657 void *argp1 = 0 ;
37658 int res1 = 0 ;
37659 bool val2 ;
37660 int ecode2 = 0 ;
37661 PyObject * obj0 = 0 ;
37662 PyObject * obj1 = 0 ;
37663 char * kwnames[] = {
37664 (char *) "self",(char *) "deleteHandler", NULL
37665 };
37666
37667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37669 if (!SWIG_IsOK(res1)) {
37670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37671 }
37672 arg1 = reinterpret_cast< wxWindow * >(argp1);
37673 if (obj1) {
37674 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37675 if (!SWIG_IsOK(ecode2)) {
37676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37677 }
37678 arg2 = static_cast< bool >(val2);
37679 }
37680 {
37681 PyThreadState* __tstate = wxPyBeginAllowThreads();
37682 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 {
37687 resultobj = wxPyMake_wxObject(result, 0);
37688 }
37689 return resultobj;
37690 fail:
37691 return NULL;
37692 }
37693
37694
37695 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37696 PyObject *resultobj = 0;
37697 wxWindow *arg1 = (wxWindow *) 0 ;
37698 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37699 bool result;
37700 void *argp1 = 0 ;
37701 int res1 = 0 ;
37702 void *argp2 = 0 ;
37703 int res2 = 0 ;
37704 PyObject * obj0 = 0 ;
37705 PyObject * obj1 = 0 ;
37706 char * kwnames[] = {
37707 (char *) "self",(char *) "handler", NULL
37708 };
37709
37710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37712 if (!SWIG_IsOK(res1)) {
37713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37714 }
37715 arg1 = reinterpret_cast< wxWindow * >(argp1);
37716 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37717 if (!SWIG_IsOK(res2)) {
37718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37719 }
37720 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37721 {
37722 PyThreadState* __tstate = wxPyBeginAllowThreads();
37723 result = (bool)(arg1)->RemoveEventHandler(arg2);
37724 wxPyEndAllowThreads(__tstate);
37725 if (PyErr_Occurred()) SWIG_fail;
37726 }
37727 {
37728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37729 }
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37737 PyObject *resultobj = 0;
37738 wxWindow *arg1 = (wxWindow *) 0 ;
37739 wxValidator *arg2 = 0 ;
37740 void *argp1 = 0 ;
37741 int res1 = 0 ;
37742 void *argp2 = 0 ;
37743 int res2 = 0 ;
37744 PyObject * obj0 = 0 ;
37745 PyObject * obj1 = 0 ;
37746 char * kwnames[] = {
37747 (char *) "self",(char *) "validator", NULL
37748 };
37749
37750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37752 if (!SWIG_IsOK(res1)) {
37753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37754 }
37755 arg1 = reinterpret_cast< wxWindow * >(argp1);
37756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37757 if (!SWIG_IsOK(res2)) {
37758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37759 }
37760 if (!argp2) {
37761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37762 }
37763 arg2 = reinterpret_cast< wxValidator * >(argp2);
37764 {
37765 PyThreadState* __tstate = wxPyBeginAllowThreads();
37766 (arg1)->SetValidator((wxValidator const &)*arg2);
37767 wxPyEndAllowThreads(__tstate);
37768 if (PyErr_Occurred()) SWIG_fail;
37769 }
37770 resultobj = SWIG_Py_Void();
37771 return resultobj;
37772 fail:
37773 return NULL;
37774 }
37775
37776
37777 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37778 PyObject *resultobj = 0;
37779 wxWindow *arg1 = (wxWindow *) 0 ;
37780 wxValidator *result = 0 ;
37781 void *argp1 = 0 ;
37782 int res1 = 0 ;
37783 PyObject *swig_obj[1] ;
37784
37785 if (!args) SWIG_fail;
37786 swig_obj[0] = args;
37787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37788 if (!SWIG_IsOK(res1)) {
37789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37790 }
37791 arg1 = reinterpret_cast< wxWindow * >(argp1);
37792 {
37793 PyThreadState* __tstate = wxPyBeginAllowThreads();
37794 result = (wxValidator *)(arg1)->GetValidator();
37795 wxPyEndAllowThreads(__tstate);
37796 if (PyErr_Occurred()) SWIG_fail;
37797 }
37798 {
37799 resultobj = wxPyMake_wxObject(result, (bool)0);
37800 }
37801 return resultobj;
37802 fail:
37803 return NULL;
37804 }
37805
37806
37807 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37808 PyObject *resultobj = 0;
37809 wxWindow *arg1 = (wxWindow *) 0 ;
37810 bool result;
37811 void *argp1 = 0 ;
37812 int res1 = 0 ;
37813 PyObject *swig_obj[1] ;
37814
37815 if (!args) SWIG_fail;
37816 swig_obj[0] = args;
37817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37818 if (!SWIG_IsOK(res1)) {
37819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37820 }
37821 arg1 = reinterpret_cast< wxWindow * >(argp1);
37822 {
37823 PyThreadState* __tstate = wxPyBeginAllowThreads();
37824 result = (bool)(arg1)->Validate();
37825 wxPyEndAllowThreads(__tstate);
37826 if (PyErr_Occurred()) SWIG_fail;
37827 }
37828 {
37829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37830 }
37831 return resultobj;
37832 fail:
37833 return NULL;
37834 }
37835
37836
37837 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37838 PyObject *resultobj = 0;
37839 wxWindow *arg1 = (wxWindow *) 0 ;
37840 bool result;
37841 void *argp1 = 0 ;
37842 int res1 = 0 ;
37843 PyObject *swig_obj[1] ;
37844
37845 if (!args) SWIG_fail;
37846 swig_obj[0] = args;
37847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37848 if (!SWIG_IsOK(res1)) {
37849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37850 }
37851 arg1 = reinterpret_cast< wxWindow * >(argp1);
37852 {
37853 PyThreadState* __tstate = wxPyBeginAllowThreads();
37854 result = (bool)(arg1)->TransferDataToWindow();
37855 wxPyEndAllowThreads(__tstate);
37856 if (PyErr_Occurred()) SWIG_fail;
37857 }
37858 {
37859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37860 }
37861 return resultobj;
37862 fail:
37863 return NULL;
37864 }
37865
37866
37867 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37868 PyObject *resultobj = 0;
37869 wxWindow *arg1 = (wxWindow *) 0 ;
37870 bool result;
37871 void *argp1 = 0 ;
37872 int res1 = 0 ;
37873 PyObject *swig_obj[1] ;
37874
37875 if (!args) SWIG_fail;
37876 swig_obj[0] = args;
37877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37878 if (!SWIG_IsOK(res1)) {
37879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37880 }
37881 arg1 = reinterpret_cast< wxWindow * >(argp1);
37882 {
37883 PyThreadState* __tstate = wxPyBeginAllowThreads();
37884 result = (bool)(arg1)->TransferDataFromWindow();
37885 wxPyEndAllowThreads(__tstate);
37886 if (PyErr_Occurred()) SWIG_fail;
37887 }
37888 {
37889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37890 }
37891 return resultobj;
37892 fail:
37893 return NULL;
37894 }
37895
37896
37897 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37898 PyObject *resultobj = 0;
37899 wxWindow *arg1 = (wxWindow *) 0 ;
37900 void *argp1 = 0 ;
37901 int res1 = 0 ;
37902 PyObject *swig_obj[1] ;
37903
37904 if (!args) SWIG_fail;
37905 swig_obj[0] = args;
37906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37907 if (!SWIG_IsOK(res1)) {
37908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37909 }
37910 arg1 = reinterpret_cast< wxWindow * >(argp1);
37911 {
37912 PyThreadState* __tstate = wxPyBeginAllowThreads();
37913 (arg1)->InitDialog();
37914 wxPyEndAllowThreads(__tstate);
37915 if (PyErr_Occurred()) SWIG_fail;
37916 }
37917 resultobj = SWIG_Py_Void();
37918 return resultobj;
37919 fail:
37920 return NULL;
37921 }
37922
37923
37924 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37925 PyObject *resultobj = 0;
37926 wxWindow *arg1 = (wxWindow *) 0 ;
37927 wxAcceleratorTable *arg2 = 0 ;
37928 void *argp1 = 0 ;
37929 int res1 = 0 ;
37930 void *argp2 = 0 ;
37931 int res2 = 0 ;
37932 PyObject * obj0 = 0 ;
37933 PyObject * obj1 = 0 ;
37934 char * kwnames[] = {
37935 (char *) "self",(char *) "accel", NULL
37936 };
37937
37938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37940 if (!SWIG_IsOK(res1)) {
37941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37942 }
37943 arg1 = reinterpret_cast< wxWindow * >(argp1);
37944 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37945 if (!SWIG_IsOK(res2)) {
37946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37947 }
37948 if (!argp2) {
37949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37950 }
37951 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37952 {
37953 PyThreadState* __tstate = wxPyBeginAllowThreads();
37954 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37955 wxPyEndAllowThreads(__tstate);
37956 if (PyErr_Occurred()) SWIG_fail;
37957 }
37958 resultobj = SWIG_Py_Void();
37959 return resultobj;
37960 fail:
37961 return NULL;
37962 }
37963
37964
37965 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37966 PyObject *resultobj = 0;
37967 wxWindow *arg1 = (wxWindow *) 0 ;
37968 wxAcceleratorTable *result = 0 ;
37969 void *argp1 = 0 ;
37970 int res1 = 0 ;
37971 PyObject *swig_obj[1] ;
37972
37973 if (!args) SWIG_fail;
37974 swig_obj[0] = args;
37975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37976 if (!SWIG_IsOK(res1)) {
37977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37978 }
37979 arg1 = reinterpret_cast< wxWindow * >(argp1);
37980 {
37981 PyThreadState* __tstate = wxPyBeginAllowThreads();
37982 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37983 wxPyEndAllowThreads(__tstate);
37984 if (PyErr_Occurred()) SWIG_fail;
37985 }
37986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37987 return resultobj;
37988 fail:
37989 return NULL;
37990 }
37991
37992
37993 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37994 PyObject *resultobj = 0;
37995 wxWindow *arg1 = (wxWindow *) 0 ;
37996 int arg2 ;
37997 int arg3 ;
37998 int arg4 ;
37999 bool result;
38000 void *argp1 = 0 ;
38001 int res1 = 0 ;
38002 int val2 ;
38003 int ecode2 = 0 ;
38004 int val3 ;
38005 int ecode3 = 0 ;
38006 int val4 ;
38007 int ecode4 = 0 ;
38008 PyObject * obj0 = 0 ;
38009 PyObject * obj1 = 0 ;
38010 PyObject * obj2 = 0 ;
38011 PyObject * obj3 = 0 ;
38012 char * kwnames[] = {
38013 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
38014 };
38015
38016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38018 if (!SWIG_IsOK(res1)) {
38019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
38020 }
38021 arg1 = reinterpret_cast< wxWindow * >(argp1);
38022 ecode2 = SWIG_AsVal_int(obj1, &val2);
38023 if (!SWIG_IsOK(ecode2)) {
38024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
38025 }
38026 arg2 = static_cast< int >(val2);
38027 ecode3 = SWIG_AsVal_int(obj2, &val3);
38028 if (!SWIG_IsOK(ecode3)) {
38029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
38030 }
38031 arg3 = static_cast< int >(val3);
38032 ecode4 = SWIG_AsVal_int(obj3, &val4);
38033 if (!SWIG_IsOK(ecode4)) {
38034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
38035 }
38036 arg4 = static_cast< int >(val4);
38037 {
38038 PyThreadState* __tstate = wxPyBeginAllowThreads();
38039 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
38040 wxPyEndAllowThreads(__tstate);
38041 if (PyErr_Occurred()) SWIG_fail;
38042 }
38043 {
38044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38045 }
38046 return resultobj;
38047 fail:
38048 return NULL;
38049 }
38050
38051
38052 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38053 PyObject *resultobj = 0;
38054 wxWindow *arg1 = (wxWindow *) 0 ;
38055 int arg2 ;
38056 bool result;
38057 void *argp1 = 0 ;
38058 int res1 = 0 ;
38059 int val2 ;
38060 int ecode2 = 0 ;
38061 PyObject * obj0 = 0 ;
38062 PyObject * obj1 = 0 ;
38063 char * kwnames[] = {
38064 (char *) "self",(char *) "hotkeyId", NULL
38065 };
38066
38067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
38068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38069 if (!SWIG_IsOK(res1)) {
38070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
38071 }
38072 arg1 = reinterpret_cast< wxWindow * >(argp1);
38073 ecode2 = SWIG_AsVal_int(obj1, &val2);
38074 if (!SWIG_IsOK(ecode2)) {
38075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
38076 }
38077 arg2 = static_cast< int >(val2);
38078 {
38079 PyThreadState* __tstate = wxPyBeginAllowThreads();
38080 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
38081 wxPyEndAllowThreads(__tstate);
38082 if (PyErr_Occurred()) SWIG_fail;
38083 }
38084 {
38085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38086 }
38087 return resultobj;
38088 fail:
38089 return NULL;
38090 }
38091
38092
38093 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38094 PyObject *resultobj = 0;
38095 wxWindow *arg1 = (wxWindow *) 0 ;
38096 wxPoint *arg2 = 0 ;
38097 wxPoint result;
38098 void *argp1 = 0 ;
38099 int res1 = 0 ;
38100 wxPoint temp2 ;
38101 PyObject * obj0 = 0 ;
38102 PyObject * obj1 = 0 ;
38103 char * kwnames[] = {
38104 (char *) "self",(char *) "pt", NULL
38105 };
38106
38107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38109 if (!SWIG_IsOK(res1)) {
38110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38111 }
38112 arg1 = reinterpret_cast< wxWindow * >(argp1);
38113 {
38114 arg2 = &temp2;
38115 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38116 }
38117 {
38118 PyThreadState* __tstate = wxPyBeginAllowThreads();
38119 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38120 wxPyEndAllowThreads(__tstate);
38121 if (PyErr_Occurred()) SWIG_fail;
38122 }
38123 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38124 return resultobj;
38125 fail:
38126 return NULL;
38127 }
38128
38129
38130 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38131 PyObject *resultobj = 0;
38132 wxWindow *arg1 = (wxWindow *) 0 ;
38133 wxSize *arg2 = 0 ;
38134 wxSize result;
38135 void *argp1 = 0 ;
38136 int res1 = 0 ;
38137 wxSize temp2 ;
38138 PyObject * obj0 = 0 ;
38139 PyObject * obj1 = 0 ;
38140 char * kwnames[] = {
38141 (char *) "self",(char *) "sz", NULL
38142 };
38143
38144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38146 if (!SWIG_IsOK(res1)) {
38147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38148 }
38149 arg1 = reinterpret_cast< wxWindow * >(argp1);
38150 {
38151 arg2 = &temp2;
38152 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38153 }
38154 {
38155 PyThreadState* __tstate = wxPyBeginAllowThreads();
38156 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38157 wxPyEndAllowThreads(__tstate);
38158 if (PyErr_Occurred()) SWIG_fail;
38159 }
38160 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38161 return resultobj;
38162 fail:
38163 return NULL;
38164 }
38165
38166
38167 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38168 PyObject *resultobj = 0;
38169 wxWindow *arg1 = (wxWindow *) 0 ;
38170 wxPoint *arg2 = 0 ;
38171 wxPoint result;
38172 void *argp1 = 0 ;
38173 int res1 = 0 ;
38174 wxPoint temp2 ;
38175 PyObject * obj0 = 0 ;
38176 PyObject * obj1 = 0 ;
38177 char * kwnames[] = {
38178 (char *) "self",(char *) "pt", NULL
38179 };
38180
38181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
38182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38183 if (!SWIG_IsOK(res1)) {
38184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
38185 }
38186 arg1 = reinterpret_cast< wxWindow * >(argp1);
38187 {
38188 arg2 = &temp2;
38189 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38190 }
38191 {
38192 PyThreadState* __tstate = wxPyBeginAllowThreads();
38193 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38194 wxPyEndAllowThreads(__tstate);
38195 if (PyErr_Occurred()) SWIG_fail;
38196 }
38197 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38198 return resultobj;
38199 fail:
38200 return NULL;
38201 }
38202
38203
38204 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38205 PyObject *resultobj = 0;
38206 wxWindow *arg1 = (wxWindow *) 0 ;
38207 wxSize *arg2 = 0 ;
38208 wxSize result;
38209 void *argp1 = 0 ;
38210 int res1 = 0 ;
38211 wxSize temp2 ;
38212 PyObject * obj0 = 0 ;
38213 PyObject * obj1 = 0 ;
38214 char * kwnames[] = {
38215 (char *) "self",(char *) "sz", NULL
38216 };
38217
38218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
38219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38220 if (!SWIG_IsOK(res1)) {
38221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
38222 }
38223 arg1 = reinterpret_cast< wxWindow * >(argp1);
38224 {
38225 arg2 = &temp2;
38226 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38227 }
38228 {
38229 PyThreadState* __tstate = wxPyBeginAllowThreads();
38230 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38235 return resultobj;
38236 fail:
38237 return NULL;
38238 }
38239
38240
38241 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38242 PyObject *resultobj = 0;
38243 wxWindow *arg1 = (wxWindow *) 0 ;
38244 wxPoint *arg2 = 0 ;
38245 wxPoint result;
38246 void *argp1 = 0 ;
38247 int res1 = 0 ;
38248 wxPoint temp2 ;
38249 PyObject * obj0 = 0 ;
38250 PyObject * obj1 = 0 ;
38251 char * kwnames[] = {
38252 (char *) "self",(char *) "pt", NULL
38253 };
38254
38255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38257 if (!SWIG_IsOK(res1)) {
38258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38259 }
38260 arg1 = reinterpret_cast< wxWindow * >(argp1);
38261 {
38262 arg2 = &temp2;
38263 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38264 }
38265 {
38266 PyThreadState* __tstate = wxPyBeginAllowThreads();
38267 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
38268 wxPyEndAllowThreads(__tstate);
38269 if (PyErr_Occurred()) SWIG_fail;
38270 }
38271 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38272 return resultobj;
38273 fail:
38274 return NULL;
38275 }
38276
38277
38278 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38279 PyObject *resultobj = 0;
38280 wxWindow *arg1 = (wxWindow *) 0 ;
38281 wxSize *arg2 = 0 ;
38282 wxSize result;
38283 void *argp1 = 0 ;
38284 int res1 = 0 ;
38285 wxSize temp2 ;
38286 PyObject * obj0 = 0 ;
38287 PyObject * obj1 = 0 ;
38288 char * kwnames[] = {
38289 (char *) "self",(char *) "sz", NULL
38290 };
38291
38292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38294 if (!SWIG_IsOK(res1)) {
38295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38296 }
38297 arg1 = reinterpret_cast< wxWindow * >(argp1);
38298 {
38299 arg2 = &temp2;
38300 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38301 }
38302 {
38303 PyThreadState* __tstate = wxPyBeginAllowThreads();
38304 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
38305 wxPyEndAllowThreads(__tstate);
38306 if (PyErr_Occurred()) SWIG_fail;
38307 }
38308 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38309 return resultobj;
38310 fail:
38311 return NULL;
38312 }
38313
38314
38315 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38316 PyObject *resultobj = 0;
38317 wxWindow *arg1 = (wxWindow *) 0 ;
38318 int arg2 ;
38319 int arg3 ;
38320 void *argp1 = 0 ;
38321 int res1 = 0 ;
38322 int val2 ;
38323 int ecode2 = 0 ;
38324 int val3 ;
38325 int ecode3 = 0 ;
38326 PyObject * obj0 = 0 ;
38327 PyObject * obj1 = 0 ;
38328 PyObject * obj2 = 0 ;
38329 char * kwnames[] = {
38330 (char *) "self",(char *) "x",(char *) "y", NULL
38331 };
38332
38333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38335 if (!SWIG_IsOK(res1)) {
38336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
38337 }
38338 arg1 = reinterpret_cast< wxWindow * >(argp1);
38339 ecode2 = SWIG_AsVal_int(obj1, &val2);
38340 if (!SWIG_IsOK(ecode2)) {
38341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
38342 }
38343 arg2 = static_cast< int >(val2);
38344 ecode3 = SWIG_AsVal_int(obj2, &val3);
38345 if (!SWIG_IsOK(ecode3)) {
38346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
38347 }
38348 arg3 = static_cast< int >(val3);
38349 {
38350 PyThreadState* __tstate = wxPyBeginAllowThreads();
38351 (arg1)->WarpPointer(arg2,arg3);
38352 wxPyEndAllowThreads(__tstate);
38353 if (PyErr_Occurred()) SWIG_fail;
38354 }
38355 resultobj = SWIG_Py_Void();
38356 return resultobj;
38357 fail:
38358 return NULL;
38359 }
38360
38361
38362 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38363 PyObject *resultobj = 0;
38364 wxWindow *arg1 = (wxWindow *) 0 ;
38365 void *argp1 = 0 ;
38366 int res1 = 0 ;
38367 PyObject *swig_obj[1] ;
38368
38369 if (!args) SWIG_fail;
38370 swig_obj[0] = args;
38371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38372 if (!SWIG_IsOK(res1)) {
38373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38374 }
38375 arg1 = reinterpret_cast< wxWindow * >(argp1);
38376 {
38377 PyThreadState* __tstate = wxPyBeginAllowThreads();
38378 (arg1)->CaptureMouse();
38379 wxPyEndAllowThreads(__tstate);
38380 if (PyErr_Occurred()) SWIG_fail;
38381 }
38382 resultobj = SWIG_Py_Void();
38383 return resultobj;
38384 fail:
38385 return NULL;
38386 }
38387
38388
38389 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38390 PyObject *resultobj = 0;
38391 wxWindow *arg1 = (wxWindow *) 0 ;
38392 void *argp1 = 0 ;
38393 int res1 = 0 ;
38394 PyObject *swig_obj[1] ;
38395
38396 if (!args) SWIG_fail;
38397 swig_obj[0] = args;
38398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38399 if (!SWIG_IsOK(res1)) {
38400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38401 }
38402 arg1 = reinterpret_cast< wxWindow * >(argp1);
38403 {
38404 PyThreadState* __tstate = wxPyBeginAllowThreads();
38405 (arg1)->ReleaseMouse();
38406 wxPyEndAllowThreads(__tstate);
38407 if (PyErr_Occurred()) SWIG_fail;
38408 }
38409 resultobj = SWIG_Py_Void();
38410 return resultobj;
38411 fail:
38412 return NULL;
38413 }
38414
38415
38416 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38417 PyObject *resultobj = 0;
38418 wxWindow *result = 0 ;
38419
38420 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
38421 {
38422 if (!wxPyCheckForApp()) SWIG_fail;
38423 PyThreadState* __tstate = wxPyBeginAllowThreads();
38424 result = (wxWindow *)wxWindow::GetCapture();
38425 wxPyEndAllowThreads(__tstate);
38426 if (PyErr_Occurred()) SWIG_fail;
38427 }
38428 {
38429 resultobj = wxPyMake_wxObject(result, 0);
38430 }
38431 return resultobj;
38432 fail:
38433 return NULL;
38434 }
38435
38436
38437 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38438 PyObject *resultobj = 0;
38439 wxWindow *arg1 = (wxWindow *) 0 ;
38440 bool result;
38441 void *argp1 = 0 ;
38442 int res1 = 0 ;
38443 PyObject *swig_obj[1] ;
38444
38445 if (!args) SWIG_fail;
38446 swig_obj[0] = args;
38447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38448 if (!SWIG_IsOK(res1)) {
38449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
38450 }
38451 arg1 = reinterpret_cast< wxWindow * >(argp1);
38452 {
38453 PyThreadState* __tstate = wxPyBeginAllowThreads();
38454 result = (bool)((wxWindow const *)arg1)->HasCapture();
38455 wxPyEndAllowThreads(__tstate);
38456 if (PyErr_Occurred()) SWIG_fail;
38457 }
38458 {
38459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38460 }
38461 return resultobj;
38462 fail:
38463 return NULL;
38464 }
38465
38466
38467 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38468 PyObject *resultobj = 0;
38469 wxWindow *arg1 = (wxWindow *) 0 ;
38470 bool arg2 = (bool) true ;
38471 wxRect *arg3 = (wxRect *) NULL ;
38472 void *argp1 = 0 ;
38473 int res1 = 0 ;
38474 bool val2 ;
38475 int ecode2 = 0 ;
38476 void *argp3 = 0 ;
38477 int res3 = 0 ;
38478 PyObject * obj0 = 0 ;
38479 PyObject * obj1 = 0 ;
38480 PyObject * obj2 = 0 ;
38481 char * kwnames[] = {
38482 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
38483 };
38484
38485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38487 if (!SWIG_IsOK(res1)) {
38488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
38489 }
38490 arg1 = reinterpret_cast< wxWindow * >(argp1);
38491 if (obj1) {
38492 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38493 if (!SWIG_IsOK(ecode2)) {
38494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
38495 }
38496 arg2 = static_cast< bool >(val2);
38497 }
38498 if (obj2) {
38499 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
38500 if (!SWIG_IsOK(res3)) {
38501 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
38502 }
38503 arg3 = reinterpret_cast< wxRect * >(argp3);
38504 }
38505 {
38506 PyThreadState* __tstate = wxPyBeginAllowThreads();
38507 (arg1)->Refresh(arg2,(wxRect const *)arg3);
38508 wxPyEndAllowThreads(__tstate);
38509 if (PyErr_Occurred()) SWIG_fail;
38510 }
38511 resultobj = SWIG_Py_Void();
38512 return resultobj;
38513 fail:
38514 return NULL;
38515 }
38516
38517
38518 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38519 PyObject *resultobj = 0;
38520 wxWindow *arg1 = (wxWindow *) 0 ;
38521 wxRect *arg2 = 0 ;
38522 bool arg3 = (bool) true ;
38523 void *argp1 = 0 ;
38524 int res1 = 0 ;
38525 wxRect temp2 ;
38526 bool val3 ;
38527 int ecode3 = 0 ;
38528 PyObject * obj0 = 0 ;
38529 PyObject * obj1 = 0 ;
38530 PyObject * obj2 = 0 ;
38531 char * kwnames[] = {
38532 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
38533 };
38534
38535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38537 if (!SWIG_IsOK(res1)) {
38538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
38539 }
38540 arg1 = reinterpret_cast< wxWindow * >(argp1);
38541 {
38542 arg2 = &temp2;
38543 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38544 }
38545 if (obj2) {
38546 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38547 if (!SWIG_IsOK(ecode3)) {
38548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38549 }
38550 arg3 = static_cast< bool >(val3);
38551 }
38552 {
38553 PyThreadState* __tstate = wxPyBeginAllowThreads();
38554 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38555 wxPyEndAllowThreads(__tstate);
38556 if (PyErr_Occurred()) SWIG_fail;
38557 }
38558 resultobj = SWIG_Py_Void();
38559 return resultobj;
38560 fail:
38561 return NULL;
38562 }
38563
38564
38565 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38566 PyObject *resultobj = 0;
38567 wxWindow *arg1 = (wxWindow *) 0 ;
38568 void *argp1 = 0 ;
38569 int res1 = 0 ;
38570 PyObject *swig_obj[1] ;
38571
38572 if (!args) SWIG_fail;
38573 swig_obj[0] = args;
38574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38575 if (!SWIG_IsOK(res1)) {
38576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38577 }
38578 arg1 = reinterpret_cast< wxWindow * >(argp1);
38579 {
38580 PyThreadState* __tstate = wxPyBeginAllowThreads();
38581 (arg1)->Update();
38582 wxPyEndAllowThreads(__tstate);
38583 if (PyErr_Occurred()) SWIG_fail;
38584 }
38585 resultobj = SWIG_Py_Void();
38586 return resultobj;
38587 fail:
38588 return NULL;
38589 }
38590
38591
38592 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38593 PyObject *resultobj = 0;
38594 wxWindow *arg1 = (wxWindow *) 0 ;
38595 void *argp1 = 0 ;
38596 int res1 = 0 ;
38597 PyObject *swig_obj[1] ;
38598
38599 if (!args) SWIG_fail;
38600 swig_obj[0] = args;
38601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38602 if (!SWIG_IsOK(res1)) {
38603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38604 }
38605 arg1 = reinterpret_cast< wxWindow * >(argp1);
38606 {
38607 PyThreadState* __tstate = wxPyBeginAllowThreads();
38608 (arg1)->ClearBackground();
38609 wxPyEndAllowThreads(__tstate);
38610 if (PyErr_Occurred()) SWIG_fail;
38611 }
38612 resultobj = SWIG_Py_Void();
38613 return resultobj;
38614 fail:
38615 return NULL;
38616 }
38617
38618
38619 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38620 PyObject *resultobj = 0;
38621 wxWindow *arg1 = (wxWindow *) 0 ;
38622 void *argp1 = 0 ;
38623 int res1 = 0 ;
38624 PyObject *swig_obj[1] ;
38625
38626 if (!args) SWIG_fail;
38627 swig_obj[0] = args;
38628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38629 if (!SWIG_IsOK(res1)) {
38630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38631 }
38632 arg1 = reinterpret_cast< wxWindow * >(argp1);
38633 {
38634 PyThreadState* __tstate = wxPyBeginAllowThreads();
38635 (arg1)->Freeze();
38636 wxPyEndAllowThreads(__tstate);
38637 if (PyErr_Occurred()) SWIG_fail;
38638 }
38639 resultobj = SWIG_Py_Void();
38640 return resultobj;
38641 fail:
38642 return NULL;
38643 }
38644
38645
38646 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38647 PyObject *resultobj = 0;
38648 wxWindow *arg1 = (wxWindow *) 0 ;
38649 bool result;
38650 void *argp1 = 0 ;
38651 int res1 = 0 ;
38652 PyObject *swig_obj[1] ;
38653
38654 if (!args) SWIG_fail;
38655 swig_obj[0] = args;
38656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38657 if (!SWIG_IsOK(res1)) {
38658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38659 }
38660 arg1 = reinterpret_cast< wxWindow * >(argp1);
38661 {
38662 PyThreadState* __tstate = wxPyBeginAllowThreads();
38663 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38664 wxPyEndAllowThreads(__tstate);
38665 if (PyErr_Occurred()) SWIG_fail;
38666 }
38667 {
38668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38669 }
38670 return resultobj;
38671 fail:
38672 return NULL;
38673 }
38674
38675
38676 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38677 PyObject *resultobj = 0;
38678 wxWindow *arg1 = (wxWindow *) 0 ;
38679 void *argp1 = 0 ;
38680 int res1 = 0 ;
38681 PyObject *swig_obj[1] ;
38682
38683 if (!args) SWIG_fail;
38684 swig_obj[0] = args;
38685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38686 if (!SWIG_IsOK(res1)) {
38687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38688 }
38689 arg1 = reinterpret_cast< wxWindow * >(argp1);
38690 {
38691 PyThreadState* __tstate = wxPyBeginAllowThreads();
38692 (arg1)->Thaw();
38693 wxPyEndAllowThreads(__tstate);
38694 if (PyErr_Occurred()) SWIG_fail;
38695 }
38696 resultobj = SWIG_Py_Void();
38697 return resultobj;
38698 fail:
38699 return NULL;
38700 }
38701
38702
38703 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38704 PyObject *resultobj = 0;
38705 wxWindow *arg1 = (wxWindow *) 0 ;
38706 wxDC *arg2 = 0 ;
38707 void *argp1 = 0 ;
38708 int res1 = 0 ;
38709 void *argp2 = 0 ;
38710 int res2 = 0 ;
38711 PyObject * obj0 = 0 ;
38712 PyObject * obj1 = 0 ;
38713 char * kwnames[] = {
38714 (char *) "self",(char *) "dc", NULL
38715 };
38716
38717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38719 if (!SWIG_IsOK(res1)) {
38720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38721 }
38722 arg1 = reinterpret_cast< wxWindow * >(argp1);
38723 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38724 if (!SWIG_IsOK(res2)) {
38725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38726 }
38727 if (!argp2) {
38728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38729 }
38730 arg2 = reinterpret_cast< wxDC * >(argp2);
38731 {
38732 PyThreadState* __tstate = wxPyBeginAllowThreads();
38733 (arg1)->PrepareDC(*arg2);
38734 wxPyEndAllowThreads(__tstate);
38735 if (PyErr_Occurred()) SWIG_fail;
38736 }
38737 resultobj = SWIG_Py_Void();
38738 return resultobj;
38739 fail:
38740 return NULL;
38741 }
38742
38743
38744 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38745 PyObject *resultobj = 0;
38746 wxWindow *arg1 = (wxWindow *) 0 ;
38747 bool result;
38748 void *argp1 = 0 ;
38749 int res1 = 0 ;
38750 PyObject *swig_obj[1] ;
38751
38752 if (!args) SWIG_fail;
38753 swig_obj[0] = args;
38754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38755 if (!SWIG_IsOK(res1)) {
38756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38757 }
38758 arg1 = reinterpret_cast< wxWindow * >(argp1);
38759 {
38760 PyThreadState* __tstate = wxPyBeginAllowThreads();
38761 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38762 wxPyEndAllowThreads(__tstate);
38763 if (PyErr_Occurred()) SWIG_fail;
38764 }
38765 {
38766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38767 }
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38775 PyObject *resultobj = 0;
38776 wxWindow *arg1 = (wxWindow *) 0 ;
38777 wxRegion *result = 0 ;
38778 void *argp1 = 0 ;
38779 int res1 = 0 ;
38780 PyObject *swig_obj[1] ;
38781
38782 if (!args) SWIG_fail;
38783 swig_obj[0] = args;
38784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38785 if (!SWIG_IsOK(res1)) {
38786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38787 }
38788 arg1 = reinterpret_cast< wxWindow * >(argp1);
38789 {
38790 PyThreadState* __tstate = wxPyBeginAllowThreads();
38791 {
38792 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38793 result = (wxRegion *) &_result_ref;
38794 }
38795 wxPyEndAllowThreads(__tstate);
38796 if (PyErr_Occurred()) SWIG_fail;
38797 }
38798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38799 return resultobj;
38800 fail:
38801 return NULL;
38802 }
38803
38804
38805 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38806 PyObject *resultobj = 0;
38807 wxWindow *arg1 = (wxWindow *) 0 ;
38808 wxRect result;
38809 void *argp1 = 0 ;
38810 int res1 = 0 ;
38811 PyObject *swig_obj[1] ;
38812
38813 if (!args) SWIG_fail;
38814 swig_obj[0] = args;
38815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38816 if (!SWIG_IsOK(res1)) {
38817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38818 }
38819 arg1 = reinterpret_cast< wxWindow * >(argp1);
38820 {
38821 PyThreadState* __tstate = wxPyBeginAllowThreads();
38822 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38823 wxPyEndAllowThreads(__tstate);
38824 if (PyErr_Occurred()) SWIG_fail;
38825 }
38826 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38827 return resultobj;
38828 fail:
38829 return NULL;
38830 }
38831
38832
38833 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38834 PyObject *resultobj = 0;
38835 wxWindow *arg1 = (wxWindow *) 0 ;
38836 int arg2 ;
38837 int arg3 ;
38838 int arg4 = (int) 1 ;
38839 int arg5 = (int) 1 ;
38840 bool result;
38841 void *argp1 = 0 ;
38842 int res1 = 0 ;
38843 int val2 ;
38844 int ecode2 = 0 ;
38845 int val3 ;
38846 int ecode3 = 0 ;
38847 int val4 ;
38848 int ecode4 = 0 ;
38849 int val5 ;
38850 int ecode5 = 0 ;
38851 PyObject * obj0 = 0 ;
38852 PyObject * obj1 = 0 ;
38853 PyObject * obj2 = 0 ;
38854 PyObject * obj3 = 0 ;
38855 PyObject * obj4 = 0 ;
38856 char * kwnames[] = {
38857 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38858 };
38859
38860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38862 if (!SWIG_IsOK(res1)) {
38863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38864 }
38865 arg1 = reinterpret_cast< wxWindow * >(argp1);
38866 ecode2 = SWIG_AsVal_int(obj1, &val2);
38867 if (!SWIG_IsOK(ecode2)) {
38868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38869 }
38870 arg2 = static_cast< int >(val2);
38871 ecode3 = SWIG_AsVal_int(obj2, &val3);
38872 if (!SWIG_IsOK(ecode3)) {
38873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38874 }
38875 arg3 = static_cast< int >(val3);
38876 if (obj3) {
38877 ecode4 = SWIG_AsVal_int(obj3, &val4);
38878 if (!SWIG_IsOK(ecode4)) {
38879 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38880 }
38881 arg4 = static_cast< int >(val4);
38882 }
38883 if (obj4) {
38884 ecode5 = SWIG_AsVal_int(obj4, &val5);
38885 if (!SWIG_IsOK(ecode5)) {
38886 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38887 }
38888 arg5 = static_cast< int >(val5);
38889 }
38890 {
38891 PyThreadState* __tstate = wxPyBeginAllowThreads();
38892 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38893 wxPyEndAllowThreads(__tstate);
38894 if (PyErr_Occurred()) SWIG_fail;
38895 }
38896 {
38897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38898 }
38899 return resultobj;
38900 fail:
38901 return NULL;
38902 }
38903
38904
38905 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38906 PyObject *resultobj = 0;
38907 wxWindow *arg1 = (wxWindow *) 0 ;
38908 wxPoint *arg2 = 0 ;
38909 bool result;
38910 void *argp1 = 0 ;
38911 int res1 = 0 ;
38912 wxPoint temp2 ;
38913 PyObject * obj0 = 0 ;
38914 PyObject * obj1 = 0 ;
38915 char * kwnames[] = {
38916 (char *) "self",(char *) "pt", NULL
38917 };
38918
38919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38921 if (!SWIG_IsOK(res1)) {
38922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38923 }
38924 arg1 = reinterpret_cast< wxWindow * >(argp1);
38925 {
38926 arg2 = &temp2;
38927 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38928 }
38929 {
38930 PyThreadState* __tstate = wxPyBeginAllowThreads();
38931 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38932 wxPyEndAllowThreads(__tstate);
38933 if (PyErr_Occurred()) SWIG_fail;
38934 }
38935 {
38936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38937 }
38938 return resultobj;
38939 fail:
38940 return NULL;
38941 }
38942
38943
38944 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38945 PyObject *resultobj = 0;
38946 wxWindow *arg1 = (wxWindow *) 0 ;
38947 wxRect *arg2 = 0 ;
38948 bool result;
38949 void *argp1 = 0 ;
38950 int res1 = 0 ;
38951 wxRect temp2 ;
38952 PyObject * obj0 = 0 ;
38953 PyObject * obj1 = 0 ;
38954 char * kwnames[] = {
38955 (char *) "self",(char *) "rect", NULL
38956 };
38957
38958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38960 if (!SWIG_IsOK(res1)) {
38961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38962 }
38963 arg1 = reinterpret_cast< wxWindow * >(argp1);
38964 {
38965 arg2 = &temp2;
38966 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38967 }
38968 {
38969 PyThreadState* __tstate = wxPyBeginAllowThreads();
38970 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38971 wxPyEndAllowThreads(__tstate);
38972 if (PyErr_Occurred()) SWIG_fail;
38973 }
38974 {
38975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38976 }
38977 return resultobj;
38978 fail:
38979 return NULL;
38980 }
38981
38982
38983 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38984 PyObject *resultobj = 0;
38985 wxWindow *arg1 = (wxWindow *) 0 ;
38986 SwigValueWrapper<wxVisualAttributes > result;
38987 void *argp1 = 0 ;
38988 int res1 = 0 ;
38989 PyObject *swig_obj[1] ;
38990
38991 if (!args) SWIG_fail;
38992 swig_obj[0] = args;
38993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38994 if (!SWIG_IsOK(res1)) {
38995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38996 }
38997 arg1 = reinterpret_cast< wxWindow * >(argp1);
38998 {
38999 PyThreadState* __tstate = wxPyBeginAllowThreads();
39000 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
39001 wxPyEndAllowThreads(__tstate);
39002 if (PyErr_Occurred()) SWIG_fail;
39003 }
39004 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
39005 return resultobj;
39006 fail:
39007 return NULL;
39008 }
39009
39010
39011 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39012 PyObject *resultobj = 0;
39013 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
39014 SwigValueWrapper<wxVisualAttributes > result;
39015 int val1 ;
39016 int ecode1 = 0 ;
39017 PyObject * obj0 = 0 ;
39018 char * kwnames[] = {
39019 (char *) "variant", NULL
39020 };
39021
39022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
39023 if (obj0) {
39024 ecode1 = SWIG_AsVal_int(obj0, &val1);
39025 if (!SWIG_IsOK(ecode1)) {
39026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
39027 }
39028 arg1 = static_cast< wxWindowVariant >(val1);
39029 }
39030 {
39031 if (!wxPyCheckForApp()) SWIG_fail;
39032 PyThreadState* __tstate = wxPyBeginAllowThreads();
39033 result = wxWindow::GetClassDefaultAttributes(arg1);
39034 wxPyEndAllowThreads(__tstate);
39035 if (PyErr_Occurred()) SWIG_fail;
39036 }
39037 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
39038 return resultobj;
39039 fail:
39040 return NULL;
39041 }
39042
39043
39044 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39045 PyObject *resultobj = 0;
39046 wxWindow *arg1 = (wxWindow *) 0 ;
39047 wxColour *arg2 = 0 ;
39048 bool result;
39049 void *argp1 = 0 ;
39050 int res1 = 0 ;
39051 wxColour temp2 ;
39052 PyObject * obj0 = 0 ;
39053 PyObject * obj1 = 0 ;
39054 char * kwnames[] = {
39055 (char *) "self",(char *) "colour", NULL
39056 };
39057
39058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39060 if (!SWIG_IsOK(res1)) {
39061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39062 }
39063 arg1 = reinterpret_cast< wxWindow * >(argp1);
39064 {
39065 arg2 = &temp2;
39066 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39067 }
39068 {
39069 PyThreadState* __tstate = wxPyBeginAllowThreads();
39070 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
39071 wxPyEndAllowThreads(__tstate);
39072 if (PyErr_Occurred()) SWIG_fail;
39073 }
39074 {
39075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39076 }
39077 return resultobj;
39078 fail:
39079 return NULL;
39080 }
39081
39082
39083 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39084 PyObject *resultobj = 0;
39085 wxWindow *arg1 = (wxWindow *) 0 ;
39086 wxColour *arg2 = 0 ;
39087 void *argp1 = 0 ;
39088 int res1 = 0 ;
39089 wxColour temp2 ;
39090 PyObject * obj0 = 0 ;
39091 PyObject * obj1 = 0 ;
39092 char * kwnames[] = {
39093 (char *) "self",(char *) "colour", NULL
39094 };
39095
39096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39098 if (!SWIG_IsOK(res1)) {
39099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39100 }
39101 arg1 = reinterpret_cast< wxWindow * >(argp1);
39102 {
39103 arg2 = &temp2;
39104 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39105 }
39106 {
39107 PyThreadState* __tstate = wxPyBeginAllowThreads();
39108 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
39109 wxPyEndAllowThreads(__tstate);
39110 if (PyErr_Occurred()) SWIG_fail;
39111 }
39112 resultobj = SWIG_Py_Void();
39113 return resultobj;
39114 fail:
39115 return NULL;
39116 }
39117
39118
39119 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39120 PyObject *resultobj = 0;
39121 wxWindow *arg1 = (wxWindow *) 0 ;
39122 wxColour *arg2 = 0 ;
39123 bool result;
39124 void *argp1 = 0 ;
39125 int res1 = 0 ;
39126 wxColour temp2 ;
39127 PyObject * obj0 = 0 ;
39128 PyObject * obj1 = 0 ;
39129 char * kwnames[] = {
39130 (char *) "self",(char *) "colour", NULL
39131 };
39132
39133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39135 if (!SWIG_IsOK(res1)) {
39136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39137 }
39138 arg1 = reinterpret_cast< wxWindow * >(argp1);
39139 {
39140 arg2 = &temp2;
39141 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39142 }
39143 {
39144 PyThreadState* __tstate = wxPyBeginAllowThreads();
39145 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
39146 wxPyEndAllowThreads(__tstate);
39147 if (PyErr_Occurred()) SWIG_fail;
39148 }
39149 {
39150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39151 }
39152 return resultobj;
39153 fail:
39154 return NULL;
39155 }
39156
39157
39158 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39159 PyObject *resultobj = 0;
39160 wxWindow *arg1 = (wxWindow *) 0 ;
39161 wxColour *arg2 = 0 ;
39162 void *argp1 = 0 ;
39163 int res1 = 0 ;
39164 wxColour temp2 ;
39165 PyObject * obj0 = 0 ;
39166 PyObject * obj1 = 0 ;
39167 char * kwnames[] = {
39168 (char *) "self",(char *) "colour", NULL
39169 };
39170
39171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39173 if (!SWIG_IsOK(res1)) {
39174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39175 }
39176 arg1 = reinterpret_cast< wxWindow * >(argp1);
39177 {
39178 arg2 = &temp2;
39179 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39180 }
39181 {
39182 PyThreadState* __tstate = wxPyBeginAllowThreads();
39183 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
39184 wxPyEndAllowThreads(__tstate);
39185 if (PyErr_Occurred()) SWIG_fail;
39186 }
39187 resultobj = SWIG_Py_Void();
39188 return resultobj;
39189 fail:
39190 return NULL;
39191 }
39192
39193
39194 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39195 PyObject *resultobj = 0;
39196 wxWindow *arg1 = (wxWindow *) 0 ;
39197 wxColour result;
39198 void *argp1 = 0 ;
39199 int res1 = 0 ;
39200 PyObject *swig_obj[1] ;
39201
39202 if (!args) SWIG_fail;
39203 swig_obj[0] = args;
39204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39205 if (!SWIG_IsOK(res1)) {
39206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39207 }
39208 arg1 = reinterpret_cast< wxWindow * >(argp1);
39209 {
39210 PyThreadState* __tstate = wxPyBeginAllowThreads();
39211 result = ((wxWindow const *)arg1)->GetBackgroundColour();
39212 wxPyEndAllowThreads(__tstate);
39213 if (PyErr_Occurred()) SWIG_fail;
39214 }
39215 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39216 return resultobj;
39217 fail:
39218 return NULL;
39219 }
39220
39221
39222 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39223 PyObject *resultobj = 0;
39224 wxWindow *arg1 = (wxWindow *) 0 ;
39225 wxColour result;
39226 void *argp1 = 0 ;
39227 int res1 = 0 ;
39228 PyObject *swig_obj[1] ;
39229
39230 if (!args) SWIG_fail;
39231 swig_obj[0] = args;
39232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39233 if (!SWIG_IsOK(res1)) {
39234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39235 }
39236 arg1 = reinterpret_cast< wxWindow * >(argp1);
39237 {
39238 PyThreadState* __tstate = wxPyBeginAllowThreads();
39239 result = ((wxWindow const *)arg1)->GetForegroundColour();
39240 wxPyEndAllowThreads(__tstate);
39241 if (PyErr_Occurred()) SWIG_fail;
39242 }
39243 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39244 return resultobj;
39245 fail:
39246 return NULL;
39247 }
39248
39249
39250 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39251 PyObject *resultobj = 0;
39252 wxWindow *arg1 = (wxWindow *) 0 ;
39253 bool result;
39254 void *argp1 = 0 ;
39255 int res1 = 0 ;
39256 PyObject *swig_obj[1] ;
39257
39258 if (!args) SWIG_fail;
39259 swig_obj[0] = args;
39260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39261 if (!SWIG_IsOK(res1)) {
39262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39263 }
39264 arg1 = reinterpret_cast< wxWindow * >(argp1);
39265 {
39266 PyThreadState* __tstate = wxPyBeginAllowThreads();
39267 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
39268 wxPyEndAllowThreads(__tstate);
39269 if (PyErr_Occurred()) SWIG_fail;
39270 }
39271 {
39272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39273 }
39274 return resultobj;
39275 fail:
39276 return NULL;
39277 }
39278
39279
39280 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39281 PyObject *resultobj = 0;
39282 wxWindow *arg1 = (wxWindow *) 0 ;
39283 bool result;
39284 void *argp1 = 0 ;
39285 int res1 = 0 ;
39286 PyObject *swig_obj[1] ;
39287
39288 if (!args) SWIG_fail;
39289 swig_obj[0] = args;
39290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39291 if (!SWIG_IsOK(res1)) {
39292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
39293 }
39294 arg1 = reinterpret_cast< wxWindow * >(argp1);
39295 {
39296 PyThreadState* __tstate = wxPyBeginAllowThreads();
39297 result = (bool)((wxWindow const *)arg1)->UseBgCol();
39298 wxPyEndAllowThreads(__tstate);
39299 if (PyErr_Occurred()) SWIG_fail;
39300 }
39301 {
39302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39303 }
39304 return resultobj;
39305 fail:
39306 return NULL;
39307 }
39308
39309
39310 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39311 PyObject *resultobj = 0;
39312 wxWindow *arg1 = (wxWindow *) 0 ;
39313 wxBackgroundStyle arg2 ;
39314 bool result;
39315 void *argp1 = 0 ;
39316 int res1 = 0 ;
39317 int val2 ;
39318 int ecode2 = 0 ;
39319 PyObject * obj0 = 0 ;
39320 PyObject * obj1 = 0 ;
39321 char * kwnames[] = {
39322 (char *) "self",(char *) "style", NULL
39323 };
39324
39325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
39326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39327 if (!SWIG_IsOK(res1)) {
39328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
39329 }
39330 arg1 = reinterpret_cast< wxWindow * >(argp1);
39331 ecode2 = SWIG_AsVal_int(obj1, &val2);
39332 if (!SWIG_IsOK(ecode2)) {
39333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
39334 }
39335 arg2 = static_cast< wxBackgroundStyle >(val2);
39336 {
39337 PyThreadState* __tstate = wxPyBeginAllowThreads();
39338 result = (bool)(arg1)->SetBackgroundStyle(arg2);
39339 wxPyEndAllowThreads(__tstate);
39340 if (PyErr_Occurred()) SWIG_fail;
39341 }
39342 {
39343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39344 }
39345 return resultobj;
39346 fail:
39347 return NULL;
39348 }
39349
39350
39351 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39352 PyObject *resultobj = 0;
39353 wxWindow *arg1 = (wxWindow *) 0 ;
39354 wxBackgroundStyle result;
39355 void *argp1 = 0 ;
39356 int res1 = 0 ;
39357 PyObject *swig_obj[1] ;
39358
39359 if (!args) SWIG_fail;
39360 swig_obj[0] = args;
39361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39362 if (!SWIG_IsOK(res1)) {
39363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
39364 }
39365 arg1 = reinterpret_cast< wxWindow * >(argp1);
39366 {
39367 PyThreadState* __tstate = wxPyBeginAllowThreads();
39368 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
39369 wxPyEndAllowThreads(__tstate);
39370 if (PyErr_Occurred()) SWIG_fail;
39371 }
39372 resultobj = SWIG_From_int(static_cast< int >(result));
39373 return resultobj;
39374 fail:
39375 return NULL;
39376 }
39377
39378
39379 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39380 PyObject *resultobj = 0;
39381 wxWindow *arg1 = (wxWindow *) 0 ;
39382 bool result;
39383 void *argp1 = 0 ;
39384 int res1 = 0 ;
39385 PyObject *swig_obj[1] ;
39386
39387 if (!args) SWIG_fail;
39388 swig_obj[0] = args;
39389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39390 if (!SWIG_IsOK(res1)) {
39391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
39392 }
39393 arg1 = reinterpret_cast< wxWindow * >(argp1);
39394 {
39395 PyThreadState* __tstate = wxPyBeginAllowThreads();
39396 result = (bool)(arg1)->HasTransparentBackground();
39397 wxPyEndAllowThreads(__tstate);
39398 if (PyErr_Occurred()) SWIG_fail;
39399 }
39400 {
39401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39402 }
39403 return resultobj;
39404 fail:
39405 return NULL;
39406 }
39407
39408
39409 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39410 PyObject *resultobj = 0;
39411 wxWindow *arg1 = (wxWindow *) 0 ;
39412 wxCursor *arg2 = 0 ;
39413 bool result;
39414 void *argp1 = 0 ;
39415 int res1 = 0 ;
39416 void *argp2 = 0 ;
39417 int res2 = 0 ;
39418 PyObject * obj0 = 0 ;
39419 PyObject * obj1 = 0 ;
39420 char * kwnames[] = {
39421 (char *) "self",(char *) "cursor", NULL
39422 };
39423
39424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
39425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39426 if (!SWIG_IsOK(res1)) {
39427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39428 }
39429 arg1 = reinterpret_cast< wxWindow * >(argp1);
39430 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
39431 if (!SWIG_IsOK(res2)) {
39432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39433 }
39434 if (!argp2) {
39435 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39436 }
39437 arg2 = reinterpret_cast< wxCursor * >(argp2);
39438 {
39439 PyThreadState* __tstate = wxPyBeginAllowThreads();
39440 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
39441 wxPyEndAllowThreads(__tstate);
39442 if (PyErr_Occurred()) SWIG_fail;
39443 }
39444 {
39445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39446 }
39447 return resultobj;
39448 fail:
39449 return NULL;
39450 }
39451
39452
39453 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39454 PyObject *resultobj = 0;
39455 wxWindow *arg1 = (wxWindow *) 0 ;
39456 wxCursor result;
39457 void *argp1 = 0 ;
39458 int res1 = 0 ;
39459 PyObject *swig_obj[1] ;
39460
39461 if (!args) SWIG_fail;
39462 swig_obj[0] = args;
39463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39464 if (!SWIG_IsOK(res1)) {
39465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39466 }
39467 arg1 = reinterpret_cast< wxWindow * >(argp1);
39468 {
39469 PyThreadState* __tstate = wxPyBeginAllowThreads();
39470 result = (arg1)->GetCursor();
39471 wxPyEndAllowThreads(__tstate);
39472 if (PyErr_Occurred()) SWIG_fail;
39473 }
39474 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
39475 return resultobj;
39476 fail:
39477 return NULL;
39478 }
39479
39480
39481 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39482 PyObject *resultobj = 0;
39483 wxWindow *arg1 = (wxWindow *) 0 ;
39484 wxFont *arg2 = 0 ;
39485 bool result;
39486 void *argp1 = 0 ;
39487 int res1 = 0 ;
39488 void *argp2 = 0 ;
39489 int res2 = 0 ;
39490 PyObject * obj0 = 0 ;
39491 PyObject * obj1 = 0 ;
39492 char * kwnames[] = {
39493 (char *) "self",(char *) "font", NULL
39494 };
39495
39496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
39497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39498 if (!SWIG_IsOK(res1)) {
39499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39500 }
39501 arg1 = reinterpret_cast< wxWindow * >(argp1);
39502 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39503 if (!SWIG_IsOK(res2)) {
39504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39505 }
39506 if (!argp2) {
39507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39508 }
39509 arg2 = reinterpret_cast< wxFont * >(argp2);
39510 {
39511 PyThreadState* __tstate = wxPyBeginAllowThreads();
39512 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
39513 wxPyEndAllowThreads(__tstate);
39514 if (PyErr_Occurred()) SWIG_fail;
39515 }
39516 {
39517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39518 }
39519 return resultobj;
39520 fail:
39521 return NULL;
39522 }
39523
39524
39525 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39526 PyObject *resultobj = 0;
39527 wxWindow *arg1 = (wxWindow *) 0 ;
39528 wxFont *arg2 = 0 ;
39529 void *argp1 = 0 ;
39530 int res1 = 0 ;
39531 void *argp2 = 0 ;
39532 int res2 = 0 ;
39533 PyObject * obj0 = 0 ;
39534 PyObject * obj1 = 0 ;
39535 char * kwnames[] = {
39536 (char *) "self",(char *) "font", NULL
39537 };
39538
39539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
39540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39541 if (!SWIG_IsOK(res1)) {
39542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39543 }
39544 arg1 = reinterpret_cast< wxWindow * >(argp1);
39545 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39546 if (!SWIG_IsOK(res2)) {
39547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39548 }
39549 if (!argp2) {
39550 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39551 }
39552 arg2 = reinterpret_cast< wxFont * >(argp2);
39553 {
39554 PyThreadState* __tstate = wxPyBeginAllowThreads();
39555 (arg1)->SetOwnFont((wxFont const &)*arg2);
39556 wxPyEndAllowThreads(__tstate);
39557 if (PyErr_Occurred()) SWIG_fail;
39558 }
39559 resultobj = SWIG_Py_Void();
39560 return resultobj;
39561 fail:
39562 return NULL;
39563 }
39564
39565
39566 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39567 PyObject *resultobj = 0;
39568 wxWindow *arg1 = (wxWindow *) 0 ;
39569 wxFont result;
39570 void *argp1 = 0 ;
39571 int res1 = 0 ;
39572 PyObject *swig_obj[1] ;
39573
39574 if (!args) SWIG_fail;
39575 swig_obj[0] = args;
39576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39577 if (!SWIG_IsOK(res1)) {
39578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39579 }
39580 arg1 = reinterpret_cast< wxWindow * >(argp1);
39581 {
39582 PyThreadState* __tstate = wxPyBeginAllowThreads();
39583 result = (arg1)->GetFont();
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39588 return resultobj;
39589 fail:
39590 return NULL;
39591 }
39592
39593
39594 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj = 0;
39596 wxWindow *arg1 = (wxWindow *) 0 ;
39597 wxCaret *arg2 = (wxCaret *) 0 ;
39598 void *argp1 = 0 ;
39599 int res1 = 0 ;
39600 int res2 = 0 ;
39601 PyObject * obj0 = 0 ;
39602 PyObject * obj1 = 0 ;
39603 char * kwnames[] = {
39604 (char *) "self",(char *) "caret", NULL
39605 };
39606
39607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39609 if (!SWIG_IsOK(res1)) {
39610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39611 }
39612 arg1 = reinterpret_cast< wxWindow * >(argp1);
39613 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39614 if (!SWIG_IsOK(res2)) {
39615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39616 }
39617 {
39618 PyThreadState* __tstate = wxPyBeginAllowThreads();
39619 (arg1)->SetCaret(arg2);
39620 wxPyEndAllowThreads(__tstate);
39621 if (PyErr_Occurred()) SWIG_fail;
39622 }
39623 resultobj = SWIG_Py_Void();
39624 return resultobj;
39625 fail:
39626 return NULL;
39627 }
39628
39629
39630 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39631 PyObject *resultobj = 0;
39632 wxWindow *arg1 = (wxWindow *) 0 ;
39633 wxCaret *result = 0 ;
39634 void *argp1 = 0 ;
39635 int res1 = 0 ;
39636 PyObject *swig_obj[1] ;
39637
39638 if (!args) SWIG_fail;
39639 swig_obj[0] = args;
39640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39641 if (!SWIG_IsOK(res1)) {
39642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39643 }
39644 arg1 = reinterpret_cast< wxWindow * >(argp1);
39645 {
39646 PyThreadState* __tstate = wxPyBeginAllowThreads();
39647 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39648 wxPyEndAllowThreads(__tstate);
39649 if (PyErr_Occurred()) SWIG_fail;
39650 }
39651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39652 return resultobj;
39653 fail:
39654 return NULL;
39655 }
39656
39657
39658 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39659 PyObject *resultobj = 0;
39660 wxWindow *arg1 = (wxWindow *) 0 ;
39661 int result;
39662 void *argp1 = 0 ;
39663 int res1 = 0 ;
39664 PyObject *swig_obj[1] ;
39665
39666 if (!args) SWIG_fail;
39667 swig_obj[0] = args;
39668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39669 if (!SWIG_IsOK(res1)) {
39670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39671 }
39672 arg1 = reinterpret_cast< wxWindow * >(argp1);
39673 {
39674 PyThreadState* __tstate = wxPyBeginAllowThreads();
39675 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39676 wxPyEndAllowThreads(__tstate);
39677 if (PyErr_Occurred()) SWIG_fail;
39678 }
39679 resultobj = SWIG_From_int(static_cast< int >(result));
39680 return resultobj;
39681 fail:
39682 return NULL;
39683 }
39684
39685
39686 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39687 PyObject *resultobj = 0;
39688 wxWindow *arg1 = (wxWindow *) 0 ;
39689 int result;
39690 void *argp1 = 0 ;
39691 int res1 = 0 ;
39692 PyObject *swig_obj[1] ;
39693
39694 if (!args) SWIG_fail;
39695 swig_obj[0] = args;
39696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39697 if (!SWIG_IsOK(res1)) {
39698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39699 }
39700 arg1 = reinterpret_cast< wxWindow * >(argp1);
39701 {
39702 PyThreadState* __tstate = wxPyBeginAllowThreads();
39703 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39704 wxPyEndAllowThreads(__tstate);
39705 if (PyErr_Occurred()) SWIG_fail;
39706 }
39707 resultobj = SWIG_From_int(static_cast< int >(result));
39708 return resultobj;
39709 fail:
39710 return NULL;
39711 }
39712
39713
39714 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39715 PyObject *resultobj = 0;
39716 wxWindow *arg1 = (wxWindow *) 0 ;
39717 wxString *arg2 = 0 ;
39718 int *arg3 = (int *) 0 ;
39719 int *arg4 = (int *) 0 ;
39720 void *argp1 = 0 ;
39721 int res1 = 0 ;
39722 bool temp2 = false ;
39723 int temp3 ;
39724 int res3 = SWIG_TMPOBJ ;
39725 int temp4 ;
39726 int res4 = SWIG_TMPOBJ ;
39727 PyObject * obj0 = 0 ;
39728 PyObject * obj1 = 0 ;
39729 char * kwnames[] = {
39730 (char *) "self",(char *) "string", NULL
39731 };
39732
39733 arg3 = &temp3;
39734 arg4 = &temp4;
39735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39737 if (!SWIG_IsOK(res1)) {
39738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39739 }
39740 arg1 = reinterpret_cast< wxWindow * >(argp1);
39741 {
39742 arg2 = wxString_in_helper(obj1);
39743 if (arg2 == NULL) SWIG_fail;
39744 temp2 = true;
39745 }
39746 {
39747 PyThreadState* __tstate = wxPyBeginAllowThreads();
39748 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39749 wxPyEndAllowThreads(__tstate);
39750 if (PyErr_Occurred()) SWIG_fail;
39751 }
39752 resultobj = SWIG_Py_Void();
39753 if (SWIG_IsTmpObj(res3)) {
39754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39755 } else {
39756 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39758 }
39759 if (SWIG_IsTmpObj(res4)) {
39760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39761 } else {
39762 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39764 }
39765 {
39766 if (temp2)
39767 delete arg2;
39768 }
39769 return resultobj;
39770 fail:
39771 {
39772 if (temp2)
39773 delete arg2;
39774 }
39775 return NULL;
39776 }
39777
39778
39779 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39780 PyObject *resultobj = 0;
39781 wxWindow *arg1 = (wxWindow *) 0 ;
39782 wxString *arg2 = 0 ;
39783 int *arg3 = (int *) 0 ;
39784 int *arg4 = (int *) 0 ;
39785 int *arg5 = (int *) 0 ;
39786 int *arg6 = (int *) 0 ;
39787 wxFont *arg7 = (wxFont *) NULL ;
39788 void *argp1 = 0 ;
39789 int res1 = 0 ;
39790 bool temp2 = false ;
39791 int temp3 ;
39792 int res3 = SWIG_TMPOBJ ;
39793 int temp4 ;
39794 int res4 = SWIG_TMPOBJ ;
39795 int temp5 ;
39796 int res5 = SWIG_TMPOBJ ;
39797 int temp6 ;
39798 int res6 = SWIG_TMPOBJ ;
39799 void *argp7 = 0 ;
39800 int res7 = 0 ;
39801 PyObject * obj0 = 0 ;
39802 PyObject * obj1 = 0 ;
39803 PyObject * obj2 = 0 ;
39804 char * kwnames[] = {
39805 (char *) "self",(char *) "string",(char *) "font", NULL
39806 };
39807
39808 arg3 = &temp3;
39809 arg4 = &temp4;
39810 arg5 = &temp5;
39811 arg6 = &temp6;
39812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39814 if (!SWIG_IsOK(res1)) {
39815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39816 }
39817 arg1 = reinterpret_cast< wxWindow * >(argp1);
39818 {
39819 arg2 = wxString_in_helper(obj1);
39820 if (arg2 == NULL) SWIG_fail;
39821 temp2 = true;
39822 }
39823 if (obj2) {
39824 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39825 if (!SWIG_IsOK(res7)) {
39826 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39827 }
39828 arg7 = reinterpret_cast< wxFont * >(argp7);
39829 }
39830 {
39831 PyThreadState* __tstate = wxPyBeginAllowThreads();
39832 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39833 wxPyEndAllowThreads(__tstate);
39834 if (PyErr_Occurred()) SWIG_fail;
39835 }
39836 resultobj = SWIG_Py_Void();
39837 if (SWIG_IsTmpObj(res3)) {
39838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39839 } else {
39840 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39842 }
39843 if (SWIG_IsTmpObj(res4)) {
39844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39845 } else {
39846 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39848 }
39849 if (SWIG_IsTmpObj(res5)) {
39850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39851 } else {
39852 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39854 }
39855 if (SWIG_IsTmpObj(res6)) {
39856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39857 } else {
39858 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39860 }
39861 {
39862 if (temp2)
39863 delete arg2;
39864 }
39865 return resultobj;
39866 fail:
39867 {
39868 if (temp2)
39869 delete arg2;
39870 }
39871 return NULL;
39872 }
39873
39874
39875 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39876 PyObject *resultobj = 0;
39877 wxWindow *arg1 = (wxWindow *) 0 ;
39878 int *arg2 = (int *) 0 ;
39879 int *arg3 = (int *) 0 ;
39880 void *argp1 = 0 ;
39881 int res1 = 0 ;
39882 int temp2 ;
39883 int res2 = 0 ;
39884 int temp3 ;
39885 int res3 = 0 ;
39886 PyObject * obj0 = 0 ;
39887 PyObject * obj1 = 0 ;
39888 PyObject * obj2 = 0 ;
39889 char * kwnames[] = {
39890 (char *) "self",(char *) "x",(char *) "y", NULL
39891 };
39892
39893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39895 if (!SWIG_IsOK(res1)) {
39896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39897 }
39898 arg1 = reinterpret_cast< wxWindow * >(argp1);
39899 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39900 int val;
39901 int ecode = SWIG_AsVal_int(obj1, &val);
39902 if (!SWIG_IsOK(ecode)) {
39903 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39904 }
39905 temp2 = static_cast< int >(val);
39906 arg2 = &temp2;
39907 res2 = SWIG_AddTmpMask(ecode);
39908 }
39909 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39910 int val;
39911 int ecode = SWIG_AsVal_int(obj2, &val);
39912 if (!SWIG_IsOK(ecode)) {
39913 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39914 }
39915 temp3 = static_cast< int >(val);
39916 arg3 = &temp3;
39917 res3 = SWIG_AddTmpMask(ecode);
39918 }
39919 {
39920 PyThreadState* __tstate = wxPyBeginAllowThreads();
39921 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39922 wxPyEndAllowThreads(__tstate);
39923 if (PyErr_Occurred()) SWIG_fail;
39924 }
39925 resultobj = SWIG_Py_Void();
39926 if (SWIG_IsTmpObj(res2)) {
39927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39928 } else {
39929 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39931 }
39932 if (SWIG_IsTmpObj(res3)) {
39933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39934 } else {
39935 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39936 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39937 }
39938 return resultobj;
39939 fail:
39940 return NULL;
39941 }
39942
39943
39944 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39945 PyObject *resultobj = 0;
39946 wxWindow *arg1 = (wxWindow *) 0 ;
39947 int *arg2 = (int *) 0 ;
39948 int *arg3 = (int *) 0 ;
39949 void *argp1 = 0 ;
39950 int res1 = 0 ;
39951 int temp2 ;
39952 int res2 = 0 ;
39953 int temp3 ;
39954 int res3 = 0 ;
39955 PyObject * obj0 = 0 ;
39956 PyObject * obj1 = 0 ;
39957 PyObject * obj2 = 0 ;
39958 char * kwnames[] = {
39959 (char *) "self",(char *) "x",(char *) "y", NULL
39960 };
39961
39962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39964 if (!SWIG_IsOK(res1)) {
39965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39966 }
39967 arg1 = reinterpret_cast< wxWindow * >(argp1);
39968 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39969 int val;
39970 int ecode = SWIG_AsVal_int(obj1, &val);
39971 if (!SWIG_IsOK(ecode)) {
39972 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39973 }
39974 temp2 = static_cast< int >(val);
39975 arg2 = &temp2;
39976 res2 = SWIG_AddTmpMask(ecode);
39977 }
39978 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39979 int val;
39980 int ecode = SWIG_AsVal_int(obj2, &val);
39981 if (!SWIG_IsOK(ecode)) {
39982 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39983 }
39984 temp3 = static_cast< int >(val);
39985 arg3 = &temp3;
39986 res3 = SWIG_AddTmpMask(ecode);
39987 }
39988 {
39989 PyThreadState* __tstate = wxPyBeginAllowThreads();
39990 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39991 wxPyEndAllowThreads(__tstate);
39992 if (PyErr_Occurred()) SWIG_fail;
39993 }
39994 resultobj = SWIG_Py_Void();
39995 if (SWIG_IsTmpObj(res2)) {
39996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39997 } else {
39998 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
40000 }
40001 if (SWIG_IsTmpObj(res3)) {
40002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
40003 } else {
40004 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
40005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
40006 }
40007 return resultobj;
40008 fail:
40009 return NULL;
40010 }
40011
40012
40013 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40014 PyObject *resultobj = 0;
40015 wxWindow *arg1 = (wxWindow *) 0 ;
40016 wxPoint *arg2 = 0 ;
40017 wxPoint result;
40018 void *argp1 = 0 ;
40019 int res1 = 0 ;
40020 wxPoint temp2 ;
40021 PyObject * obj0 = 0 ;
40022 PyObject * obj1 = 0 ;
40023 char * kwnames[] = {
40024 (char *) "self",(char *) "pt", NULL
40025 };
40026
40027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
40028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40029 if (!SWIG_IsOK(res1)) {
40030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
40031 }
40032 arg1 = reinterpret_cast< wxWindow * >(argp1);
40033 {
40034 arg2 = &temp2;
40035 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40036 }
40037 {
40038 PyThreadState* __tstate = wxPyBeginAllowThreads();
40039 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
40040 wxPyEndAllowThreads(__tstate);
40041 if (PyErr_Occurred()) SWIG_fail;
40042 }
40043 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40044 return resultobj;
40045 fail:
40046 return NULL;
40047 }
40048
40049
40050 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40051 PyObject *resultobj = 0;
40052 wxWindow *arg1 = (wxWindow *) 0 ;
40053 wxPoint *arg2 = 0 ;
40054 wxPoint result;
40055 void *argp1 = 0 ;
40056 int res1 = 0 ;
40057 wxPoint temp2 ;
40058 PyObject * obj0 = 0 ;
40059 PyObject * obj1 = 0 ;
40060 char * kwnames[] = {
40061 (char *) "self",(char *) "pt", NULL
40062 };
40063
40064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
40065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40066 if (!SWIG_IsOK(res1)) {
40067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
40068 }
40069 arg1 = reinterpret_cast< wxWindow * >(argp1);
40070 {
40071 arg2 = &temp2;
40072 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40073 }
40074 {
40075 PyThreadState* __tstate = wxPyBeginAllowThreads();
40076 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
40077 wxPyEndAllowThreads(__tstate);
40078 if (PyErr_Occurred()) SWIG_fail;
40079 }
40080 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj = 0;
40089 wxWindow *arg1 = (wxWindow *) 0 ;
40090 int arg2 ;
40091 int arg3 ;
40092 wxHitTest result;
40093 void *argp1 = 0 ;
40094 int res1 = 0 ;
40095 int val2 ;
40096 int ecode2 = 0 ;
40097 int val3 ;
40098 int ecode3 = 0 ;
40099 PyObject * obj0 = 0 ;
40100 PyObject * obj1 = 0 ;
40101 PyObject * obj2 = 0 ;
40102 char * kwnames[] = {
40103 (char *) "self",(char *) "x",(char *) "y", NULL
40104 };
40105
40106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40108 if (!SWIG_IsOK(res1)) {
40109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
40110 }
40111 arg1 = reinterpret_cast< wxWindow * >(argp1);
40112 ecode2 = SWIG_AsVal_int(obj1, &val2);
40113 if (!SWIG_IsOK(ecode2)) {
40114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
40115 }
40116 arg2 = static_cast< int >(val2);
40117 ecode3 = SWIG_AsVal_int(obj2, &val3);
40118 if (!SWIG_IsOK(ecode3)) {
40119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
40120 }
40121 arg3 = static_cast< int >(val3);
40122 {
40123 PyThreadState* __tstate = wxPyBeginAllowThreads();
40124 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
40125 wxPyEndAllowThreads(__tstate);
40126 if (PyErr_Occurred()) SWIG_fail;
40127 }
40128 resultobj = SWIG_From_int(static_cast< int >(result));
40129 return resultobj;
40130 fail:
40131 return NULL;
40132 }
40133
40134
40135 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40136 PyObject *resultobj = 0;
40137 wxWindow *arg1 = (wxWindow *) 0 ;
40138 wxPoint *arg2 = 0 ;
40139 wxHitTest result;
40140 void *argp1 = 0 ;
40141 int res1 = 0 ;
40142 wxPoint temp2 ;
40143 PyObject * obj0 = 0 ;
40144 PyObject * obj1 = 0 ;
40145 char * kwnames[] = {
40146 (char *) "self",(char *) "pt", NULL
40147 };
40148
40149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
40150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40151 if (!SWIG_IsOK(res1)) {
40152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
40153 }
40154 arg1 = reinterpret_cast< wxWindow * >(argp1);
40155 {
40156 arg2 = &temp2;
40157 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40158 }
40159 {
40160 PyThreadState* __tstate = wxPyBeginAllowThreads();
40161 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
40162 wxPyEndAllowThreads(__tstate);
40163 if (PyErr_Occurred()) SWIG_fail;
40164 }
40165 resultobj = SWIG_From_int(static_cast< int >(result));
40166 return resultobj;
40167 fail:
40168 return NULL;
40169 }
40170
40171
40172 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40173 PyObject *resultobj = 0;
40174 wxWindow *arg1 = (wxWindow *) 0 ;
40175 long arg2 ;
40176 wxBorder result;
40177 void *argp1 = 0 ;
40178 int res1 = 0 ;
40179 long val2 ;
40180 int ecode2 = 0 ;
40181
40182 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
40183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40184 if (!SWIG_IsOK(res1)) {
40185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40186 }
40187 arg1 = reinterpret_cast< wxWindow * >(argp1);
40188 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
40189 if (!SWIG_IsOK(ecode2)) {
40190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
40191 }
40192 arg2 = static_cast< long >(val2);
40193 {
40194 PyThreadState* __tstate = wxPyBeginAllowThreads();
40195 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
40196 wxPyEndAllowThreads(__tstate);
40197 if (PyErr_Occurred()) SWIG_fail;
40198 }
40199 resultobj = SWIG_From_int(static_cast< int >(result));
40200 return resultobj;
40201 fail:
40202 return NULL;
40203 }
40204
40205
40206 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40207 PyObject *resultobj = 0;
40208 wxWindow *arg1 = (wxWindow *) 0 ;
40209 wxBorder result;
40210 void *argp1 = 0 ;
40211 int res1 = 0 ;
40212
40213 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
40214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40215 if (!SWIG_IsOK(res1)) {
40216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40217 }
40218 arg1 = reinterpret_cast< wxWindow * >(argp1);
40219 {
40220 PyThreadState* __tstate = wxPyBeginAllowThreads();
40221 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
40222 wxPyEndAllowThreads(__tstate);
40223 if (PyErr_Occurred()) SWIG_fail;
40224 }
40225 resultobj = SWIG_From_int(static_cast< int >(result));
40226 return resultobj;
40227 fail:
40228 return NULL;
40229 }
40230
40231
40232 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
40233 int argc;
40234 PyObject *argv[3];
40235
40236 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
40237 --argc;
40238 if (argc == 1) {
40239 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
40240 }
40241 if (argc == 2) {
40242 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
40243 }
40244
40245 fail:
40246 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
40247 return NULL;
40248 }
40249
40250
40251 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40252 PyObject *resultobj = 0;
40253 wxWindow *arg1 = (wxWindow *) 0 ;
40254 long arg2 = (long) wxUPDATE_UI_NONE ;
40255 void *argp1 = 0 ;
40256 int res1 = 0 ;
40257 long val2 ;
40258 int ecode2 = 0 ;
40259 PyObject * obj0 = 0 ;
40260 PyObject * obj1 = 0 ;
40261 char * kwnames[] = {
40262 (char *) "self",(char *) "flags", NULL
40263 };
40264
40265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) 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_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
40269 }
40270 arg1 = reinterpret_cast< wxWindow * >(argp1);
40271 if (obj1) {
40272 ecode2 = SWIG_AsVal_long(obj1, &val2);
40273 if (!SWIG_IsOK(ecode2)) {
40274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
40275 }
40276 arg2 = static_cast< long >(val2);
40277 }
40278 {
40279 PyThreadState* __tstate = wxPyBeginAllowThreads();
40280 (arg1)->UpdateWindowUI(arg2);
40281 wxPyEndAllowThreads(__tstate);
40282 if (PyErr_Occurred()) SWIG_fail;
40283 }
40284 resultobj = SWIG_Py_Void();
40285 return resultobj;
40286 fail:
40287 return NULL;
40288 }
40289
40290
40291 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40292 PyObject *resultobj = 0;
40293 wxWindow *arg1 = (wxWindow *) 0 ;
40294 wxMenu *arg2 = (wxMenu *) 0 ;
40295 int arg3 = (int) -1 ;
40296 int arg4 = (int) -1 ;
40297 bool result;
40298 void *argp1 = 0 ;
40299 int res1 = 0 ;
40300 void *argp2 = 0 ;
40301 int res2 = 0 ;
40302 int val3 ;
40303 int ecode3 = 0 ;
40304 int val4 ;
40305 int ecode4 = 0 ;
40306 PyObject * obj0 = 0 ;
40307 PyObject * obj1 = 0 ;
40308 PyObject * obj2 = 0 ;
40309 PyObject * obj3 = 0 ;
40310 char * kwnames[] = {
40311 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
40312 };
40313
40314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40316 if (!SWIG_IsOK(res1)) {
40317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
40318 }
40319 arg1 = reinterpret_cast< wxWindow * >(argp1);
40320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40321 if (!SWIG_IsOK(res2)) {
40322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
40323 }
40324 arg2 = reinterpret_cast< wxMenu * >(argp2);
40325 if (obj2) {
40326 ecode3 = SWIG_AsVal_int(obj2, &val3);
40327 if (!SWIG_IsOK(ecode3)) {
40328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
40329 }
40330 arg3 = static_cast< int >(val3);
40331 }
40332 if (obj3) {
40333 ecode4 = SWIG_AsVal_int(obj3, &val4);
40334 if (!SWIG_IsOK(ecode4)) {
40335 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
40336 }
40337 arg4 = static_cast< int >(val4);
40338 }
40339 {
40340 PyThreadState* __tstate = wxPyBeginAllowThreads();
40341 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
40342 wxPyEndAllowThreads(__tstate);
40343 if (PyErr_Occurred()) SWIG_fail;
40344 }
40345 {
40346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40347 }
40348 return resultobj;
40349 fail:
40350 return NULL;
40351 }
40352
40353
40354 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40355 PyObject *resultobj = 0;
40356 wxWindow *arg1 = (wxWindow *) 0 ;
40357 wxMenu *arg2 = (wxMenu *) 0 ;
40358 wxPoint const &arg3_defvalue = wxDefaultPosition ;
40359 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
40360 bool result;
40361 void *argp1 = 0 ;
40362 int res1 = 0 ;
40363 void *argp2 = 0 ;
40364 int res2 = 0 ;
40365 wxPoint temp3 ;
40366 PyObject * obj0 = 0 ;
40367 PyObject * obj1 = 0 ;
40368 PyObject * obj2 = 0 ;
40369 char * kwnames[] = {
40370 (char *) "self",(char *) "menu",(char *) "pos", NULL
40371 };
40372
40373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40375 if (!SWIG_IsOK(res1)) {
40376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
40377 }
40378 arg1 = reinterpret_cast< wxWindow * >(argp1);
40379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40380 if (!SWIG_IsOK(res2)) {
40381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
40382 }
40383 arg2 = reinterpret_cast< wxMenu * >(argp2);
40384 if (obj2) {
40385 {
40386 arg3 = &temp3;
40387 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
40388 }
40389 }
40390 {
40391 PyThreadState* __tstate = wxPyBeginAllowThreads();
40392 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
40393 wxPyEndAllowThreads(__tstate);
40394 if (PyErr_Occurred()) SWIG_fail;
40395 }
40396 {
40397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40398 }
40399 return resultobj;
40400 fail:
40401 return NULL;
40402 }
40403
40404
40405 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40406 PyObject *resultobj = 0;
40407 wxWindow *arg1 = (wxWindow *) 0 ;
40408 bool result;
40409 void *argp1 = 0 ;
40410 int res1 = 0 ;
40411 PyObject *swig_obj[1] ;
40412
40413 if (!args) SWIG_fail;
40414 swig_obj[0] = args;
40415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40416 if (!SWIG_IsOK(res1)) {
40417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
40418 }
40419 arg1 = reinterpret_cast< wxWindow * >(argp1);
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
40423 wxPyEndAllowThreads(__tstate);
40424 if (PyErr_Occurred()) SWIG_fail;
40425 }
40426 {
40427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40428 }
40429 return resultobj;
40430 fail:
40431 return NULL;
40432 }
40433
40434
40435 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40436 PyObject *resultobj = 0;
40437 wxWindow *arg1 = (wxWindow *) 0 ;
40438 long result;
40439 void *argp1 = 0 ;
40440 int res1 = 0 ;
40441 PyObject *swig_obj[1] ;
40442
40443 if (!args) SWIG_fail;
40444 swig_obj[0] = args;
40445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40446 if (!SWIG_IsOK(res1)) {
40447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40448 }
40449 arg1 = reinterpret_cast< wxWindow * >(argp1);
40450 {
40451 PyThreadState* __tstate = wxPyBeginAllowThreads();
40452 result = (long)wxWindow_GetHandle(arg1);
40453 wxPyEndAllowThreads(__tstate);
40454 if (PyErr_Occurred()) SWIG_fail;
40455 }
40456 resultobj = SWIG_From_long(static_cast< long >(result));
40457 return resultobj;
40458 fail:
40459 return NULL;
40460 }
40461
40462
40463 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40464 PyObject *resultobj = 0;
40465 wxWindow *arg1 = (wxWindow *) 0 ;
40466 long arg2 ;
40467 void *argp1 = 0 ;
40468 int res1 = 0 ;
40469 long val2 ;
40470 int ecode2 = 0 ;
40471 PyObject * obj0 = 0 ;
40472 PyObject * obj1 = 0 ;
40473 char * kwnames[] = {
40474 (char *) "self",(char *) "handle", NULL
40475 };
40476
40477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
40478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40479 if (!SWIG_IsOK(res1)) {
40480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40481 }
40482 arg1 = reinterpret_cast< wxWindow * >(argp1);
40483 ecode2 = SWIG_AsVal_long(obj1, &val2);
40484 if (!SWIG_IsOK(ecode2)) {
40485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
40486 }
40487 arg2 = static_cast< long >(val2);
40488 {
40489 PyThreadState* __tstate = wxPyBeginAllowThreads();
40490 wxWindow_AssociateHandle(arg1,arg2);
40491 wxPyEndAllowThreads(__tstate);
40492 if (PyErr_Occurred()) SWIG_fail;
40493 }
40494 resultobj = SWIG_Py_Void();
40495 return resultobj;
40496 fail:
40497 return NULL;
40498 }
40499
40500
40501 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40502 PyObject *resultobj = 0;
40503 wxWindow *arg1 = (wxWindow *) 0 ;
40504 void *argp1 = 0 ;
40505 int res1 = 0 ;
40506 PyObject *swig_obj[1] ;
40507
40508 if (!args) SWIG_fail;
40509 swig_obj[0] = args;
40510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40511 if (!SWIG_IsOK(res1)) {
40512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40513 }
40514 arg1 = reinterpret_cast< wxWindow * >(argp1);
40515 {
40516 PyThreadState* __tstate = wxPyBeginAllowThreads();
40517 (arg1)->DissociateHandle();
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 resultobj = SWIG_Py_Void();
40522 return resultobj;
40523 fail:
40524 return NULL;
40525 }
40526
40527
40528 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40529 PyObject *resultobj = 0;
40530 wxWindow *arg1 = (wxWindow *) 0 ;
40531 wxPaintEvent *arg2 = 0 ;
40532 void *argp1 = 0 ;
40533 int res1 = 0 ;
40534 void *argp2 = 0 ;
40535 int res2 = 0 ;
40536 PyObject * obj0 = 0 ;
40537 PyObject * obj1 = 0 ;
40538 char * kwnames[] = {
40539 (char *) "self",(char *) "event", NULL
40540 };
40541
40542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
40543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40544 if (!SWIG_IsOK(res1)) {
40545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
40546 }
40547 arg1 = reinterpret_cast< wxWindow * >(argp1);
40548 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
40549 if (!SWIG_IsOK(res2)) {
40550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
40551 }
40552 if (!argp2) {
40553 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
40554 }
40555 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
40556 {
40557 PyThreadState* __tstate = wxPyBeginAllowThreads();
40558 (arg1)->OnPaint(*arg2);
40559 wxPyEndAllowThreads(__tstate);
40560 if (PyErr_Occurred()) SWIG_fail;
40561 }
40562 resultobj = SWIG_Py_Void();
40563 return resultobj;
40564 fail:
40565 return NULL;
40566 }
40567
40568
40569 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40570 PyObject *resultobj = 0;
40571 wxWindow *arg1 = (wxWindow *) 0 ;
40572 int arg2 ;
40573 bool result;
40574 void *argp1 = 0 ;
40575 int res1 = 0 ;
40576 int val2 ;
40577 int ecode2 = 0 ;
40578 PyObject * obj0 = 0 ;
40579 PyObject * obj1 = 0 ;
40580 char * kwnames[] = {
40581 (char *) "self",(char *) "orient", NULL
40582 };
40583
40584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40586 if (!SWIG_IsOK(res1)) {
40587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40588 }
40589 arg1 = reinterpret_cast< wxWindow * >(argp1);
40590 ecode2 = SWIG_AsVal_int(obj1, &val2);
40591 if (!SWIG_IsOK(ecode2)) {
40592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40593 }
40594 arg2 = static_cast< int >(val2);
40595 {
40596 PyThreadState* __tstate = wxPyBeginAllowThreads();
40597 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40598 wxPyEndAllowThreads(__tstate);
40599 if (PyErr_Occurred()) SWIG_fail;
40600 }
40601 {
40602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40603 }
40604 return resultobj;
40605 fail:
40606 return NULL;
40607 }
40608
40609
40610 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40611 PyObject *resultobj = 0;
40612 wxWindow *arg1 = (wxWindow *) 0 ;
40613 int arg2 ;
40614 int arg3 ;
40615 int arg4 ;
40616 int arg5 ;
40617 bool arg6 = (bool) true ;
40618 void *argp1 = 0 ;
40619 int res1 = 0 ;
40620 int val2 ;
40621 int ecode2 = 0 ;
40622 int val3 ;
40623 int ecode3 = 0 ;
40624 int val4 ;
40625 int ecode4 = 0 ;
40626 int val5 ;
40627 int ecode5 = 0 ;
40628 bool val6 ;
40629 int ecode6 = 0 ;
40630 PyObject * obj0 = 0 ;
40631 PyObject * obj1 = 0 ;
40632 PyObject * obj2 = 0 ;
40633 PyObject * obj3 = 0 ;
40634 PyObject * obj4 = 0 ;
40635 PyObject * obj5 = 0 ;
40636 char * kwnames[] = {
40637 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40638 };
40639
40640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40642 if (!SWIG_IsOK(res1)) {
40643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40644 }
40645 arg1 = reinterpret_cast< wxWindow * >(argp1);
40646 ecode2 = SWIG_AsVal_int(obj1, &val2);
40647 if (!SWIG_IsOK(ecode2)) {
40648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40649 }
40650 arg2 = static_cast< int >(val2);
40651 ecode3 = SWIG_AsVal_int(obj2, &val3);
40652 if (!SWIG_IsOK(ecode3)) {
40653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40654 }
40655 arg3 = static_cast< int >(val3);
40656 ecode4 = SWIG_AsVal_int(obj3, &val4);
40657 if (!SWIG_IsOK(ecode4)) {
40658 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40659 }
40660 arg4 = static_cast< int >(val4);
40661 ecode5 = SWIG_AsVal_int(obj4, &val5);
40662 if (!SWIG_IsOK(ecode5)) {
40663 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40664 }
40665 arg5 = static_cast< int >(val5);
40666 if (obj5) {
40667 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40668 if (!SWIG_IsOK(ecode6)) {
40669 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40670 }
40671 arg6 = static_cast< bool >(val6);
40672 }
40673 {
40674 PyThreadState* __tstate = wxPyBeginAllowThreads();
40675 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40676 wxPyEndAllowThreads(__tstate);
40677 if (PyErr_Occurred()) SWIG_fail;
40678 }
40679 resultobj = SWIG_Py_Void();
40680 return resultobj;
40681 fail:
40682 return NULL;
40683 }
40684
40685
40686 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40687 PyObject *resultobj = 0;
40688 wxWindow *arg1 = (wxWindow *) 0 ;
40689 int arg2 ;
40690 int arg3 ;
40691 bool arg4 = (bool) true ;
40692 void *argp1 = 0 ;
40693 int res1 = 0 ;
40694 int val2 ;
40695 int ecode2 = 0 ;
40696 int val3 ;
40697 int ecode3 = 0 ;
40698 bool val4 ;
40699 int ecode4 = 0 ;
40700 PyObject * obj0 = 0 ;
40701 PyObject * obj1 = 0 ;
40702 PyObject * obj2 = 0 ;
40703 PyObject * obj3 = 0 ;
40704 char * kwnames[] = {
40705 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40706 };
40707
40708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40710 if (!SWIG_IsOK(res1)) {
40711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40712 }
40713 arg1 = reinterpret_cast< wxWindow * >(argp1);
40714 ecode2 = SWIG_AsVal_int(obj1, &val2);
40715 if (!SWIG_IsOK(ecode2)) {
40716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40717 }
40718 arg2 = static_cast< int >(val2);
40719 ecode3 = SWIG_AsVal_int(obj2, &val3);
40720 if (!SWIG_IsOK(ecode3)) {
40721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40722 }
40723 arg3 = static_cast< int >(val3);
40724 if (obj3) {
40725 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40726 if (!SWIG_IsOK(ecode4)) {
40727 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40728 }
40729 arg4 = static_cast< bool >(val4);
40730 }
40731 {
40732 PyThreadState* __tstate = wxPyBeginAllowThreads();
40733 (arg1)->SetScrollPos(arg2,arg3,arg4);
40734 wxPyEndAllowThreads(__tstate);
40735 if (PyErr_Occurred()) SWIG_fail;
40736 }
40737 resultobj = SWIG_Py_Void();
40738 return resultobj;
40739 fail:
40740 return NULL;
40741 }
40742
40743
40744 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40745 PyObject *resultobj = 0;
40746 wxWindow *arg1 = (wxWindow *) 0 ;
40747 int arg2 ;
40748 int result;
40749 void *argp1 = 0 ;
40750 int res1 = 0 ;
40751 int val2 ;
40752 int ecode2 = 0 ;
40753 PyObject * obj0 = 0 ;
40754 PyObject * obj1 = 0 ;
40755 char * kwnames[] = {
40756 (char *) "self",(char *) "orientation", NULL
40757 };
40758
40759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40761 if (!SWIG_IsOK(res1)) {
40762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40763 }
40764 arg1 = reinterpret_cast< wxWindow * >(argp1);
40765 ecode2 = SWIG_AsVal_int(obj1, &val2);
40766 if (!SWIG_IsOK(ecode2)) {
40767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40768 }
40769 arg2 = static_cast< int >(val2);
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40773 wxPyEndAllowThreads(__tstate);
40774 if (PyErr_Occurred()) SWIG_fail;
40775 }
40776 resultobj = SWIG_From_int(static_cast< int >(result));
40777 return resultobj;
40778 fail:
40779 return NULL;
40780 }
40781
40782
40783 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40784 PyObject *resultobj = 0;
40785 wxWindow *arg1 = (wxWindow *) 0 ;
40786 int arg2 ;
40787 int result;
40788 void *argp1 = 0 ;
40789 int res1 = 0 ;
40790 int val2 ;
40791 int ecode2 = 0 ;
40792 PyObject * obj0 = 0 ;
40793 PyObject * obj1 = 0 ;
40794 char * kwnames[] = {
40795 (char *) "self",(char *) "orientation", NULL
40796 };
40797
40798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40800 if (!SWIG_IsOK(res1)) {
40801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40802 }
40803 arg1 = reinterpret_cast< wxWindow * >(argp1);
40804 ecode2 = SWIG_AsVal_int(obj1, &val2);
40805 if (!SWIG_IsOK(ecode2)) {
40806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40807 }
40808 arg2 = static_cast< int >(val2);
40809 {
40810 PyThreadState* __tstate = wxPyBeginAllowThreads();
40811 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40812 wxPyEndAllowThreads(__tstate);
40813 if (PyErr_Occurred()) SWIG_fail;
40814 }
40815 resultobj = SWIG_From_int(static_cast< int >(result));
40816 return resultobj;
40817 fail:
40818 return NULL;
40819 }
40820
40821
40822 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40823 PyObject *resultobj = 0;
40824 wxWindow *arg1 = (wxWindow *) 0 ;
40825 int arg2 ;
40826 int result;
40827 void *argp1 = 0 ;
40828 int res1 = 0 ;
40829 int val2 ;
40830 int ecode2 = 0 ;
40831 PyObject * obj0 = 0 ;
40832 PyObject * obj1 = 0 ;
40833 char * kwnames[] = {
40834 (char *) "self",(char *) "orientation", NULL
40835 };
40836
40837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40839 if (!SWIG_IsOK(res1)) {
40840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40841 }
40842 arg1 = reinterpret_cast< wxWindow * >(argp1);
40843 ecode2 = SWIG_AsVal_int(obj1, &val2);
40844 if (!SWIG_IsOK(ecode2)) {
40845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40846 }
40847 arg2 = static_cast< int >(val2);
40848 {
40849 PyThreadState* __tstate = wxPyBeginAllowThreads();
40850 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40851 wxPyEndAllowThreads(__tstate);
40852 if (PyErr_Occurred()) SWIG_fail;
40853 }
40854 resultobj = SWIG_From_int(static_cast< int >(result));
40855 return resultobj;
40856 fail:
40857 return NULL;
40858 }
40859
40860
40861 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40862 PyObject *resultobj = 0;
40863 wxWindow *arg1 = (wxWindow *) 0 ;
40864 int arg2 ;
40865 int arg3 ;
40866 wxRect *arg4 = (wxRect *) NULL ;
40867 void *argp1 = 0 ;
40868 int res1 = 0 ;
40869 int val2 ;
40870 int ecode2 = 0 ;
40871 int val3 ;
40872 int ecode3 = 0 ;
40873 void *argp4 = 0 ;
40874 int res4 = 0 ;
40875 PyObject * obj0 = 0 ;
40876 PyObject * obj1 = 0 ;
40877 PyObject * obj2 = 0 ;
40878 PyObject * obj3 = 0 ;
40879 char * kwnames[] = {
40880 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40881 };
40882
40883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40885 if (!SWIG_IsOK(res1)) {
40886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40887 }
40888 arg1 = reinterpret_cast< wxWindow * >(argp1);
40889 ecode2 = SWIG_AsVal_int(obj1, &val2);
40890 if (!SWIG_IsOK(ecode2)) {
40891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40892 }
40893 arg2 = static_cast< int >(val2);
40894 ecode3 = SWIG_AsVal_int(obj2, &val3);
40895 if (!SWIG_IsOK(ecode3)) {
40896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40897 }
40898 arg3 = static_cast< int >(val3);
40899 if (obj3) {
40900 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40901 if (!SWIG_IsOK(res4)) {
40902 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40903 }
40904 arg4 = reinterpret_cast< wxRect * >(argp4);
40905 }
40906 {
40907 PyThreadState* __tstate = wxPyBeginAllowThreads();
40908 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40909 wxPyEndAllowThreads(__tstate);
40910 if (PyErr_Occurred()) SWIG_fail;
40911 }
40912 resultobj = SWIG_Py_Void();
40913 return resultobj;
40914 fail:
40915 return NULL;
40916 }
40917
40918
40919 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40920 PyObject *resultobj = 0;
40921 wxWindow *arg1 = (wxWindow *) 0 ;
40922 int arg2 ;
40923 bool result;
40924 void *argp1 = 0 ;
40925 int res1 = 0 ;
40926 int val2 ;
40927 int ecode2 = 0 ;
40928 PyObject * obj0 = 0 ;
40929 PyObject * obj1 = 0 ;
40930 char * kwnames[] = {
40931 (char *) "self",(char *) "lines", NULL
40932 };
40933
40934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40936 if (!SWIG_IsOK(res1)) {
40937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40938 }
40939 arg1 = reinterpret_cast< wxWindow * >(argp1);
40940 ecode2 = SWIG_AsVal_int(obj1, &val2);
40941 if (!SWIG_IsOK(ecode2)) {
40942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40943 }
40944 arg2 = static_cast< int >(val2);
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 result = (bool)(arg1)->ScrollLines(arg2);
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 {
40952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40953 }
40954 return resultobj;
40955 fail:
40956 return NULL;
40957 }
40958
40959
40960 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40961 PyObject *resultobj = 0;
40962 wxWindow *arg1 = (wxWindow *) 0 ;
40963 int arg2 ;
40964 bool result;
40965 void *argp1 = 0 ;
40966 int res1 = 0 ;
40967 int val2 ;
40968 int ecode2 = 0 ;
40969 PyObject * obj0 = 0 ;
40970 PyObject * obj1 = 0 ;
40971 char * kwnames[] = {
40972 (char *) "self",(char *) "pages", NULL
40973 };
40974
40975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40977 if (!SWIG_IsOK(res1)) {
40978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40979 }
40980 arg1 = reinterpret_cast< wxWindow * >(argp1);
40981 ecode2 = SWIG_AsVal_int(obj1, &val2);
40982 if (!SWIG_IsOK(ecode2)) {
40983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40984 }
40985 arg2 = static_cast< int >(val2);
40986 {
40987 PyThreadState* __tstate = wxPyBeginAllowThreads();
40988 result = (bool)(arg1)->ScrollPages(arg2);
40989 wxPyEndAllowThreads(__tstate);
40990 if (PyErr_Occurred()) SWIG_fail;
40991 }
40992 {
40993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40994 }
40995 return resultobj;
40996 fail:
40997 return NULL;
40998 }
40999
41000
41001 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41002 PyObject *resultobj = 0;
41003 wxWindow *arg1 = (wxWindow *) 0 ;
41004 bool result;
41005 void *argp1 = 0 ;
41006 int res1 = 0 ;
41007 PyObject *swig_obj[1] ;
41008
41009 if (!args) SWIG_fail;
41010 swig_obj[0] = args;
41011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41012 if (!SWIG_IsOK(res1)) {
41013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
41014 }
41015 arg1 = reinterpret_cast< wxWindow * >(argp1);
41016 {
41017 PyThreadState* __tstate = wxPyBeginAllowThreads();
41018 result = (bool)(arg1)->LineUp();
41019 wxPyEndAllowThreads(__tstate);
41020 if (PyErr_Occurred()) SWIG_fail;
41021 }
41022 {
41023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41024 }
41025 return resultobj;
41026 fail:
41027 return NULL;
41028 }
41029
41030
41031 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41032 PyObject *resultobj = 0;
41033 wxWindow *arg1 = (wxWindow *) 0 ;
41034 bool result;
41035 void *argp1 = 0 ;
41036 int res1 = 0 ;
41037 PyObject *swig_obj[1] ;
41038
41039 if (!args) SWIG_fail;
41040 swig_obj[0] = args;
41041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41042 if (!SWIG_IsOK(res1)) {
41043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41044 }
41045 arg1 = reinterpret_cast< wxWindow * >(argp1);
41046 {
41047 PyThreadState* __tstate = wxPyBeginAllowThreads();
41048 result = (bool)(arg1)->LineDown();
41049 wxPyEndAllowThreads(__tstate);
41050 if (PyErr_Occurred()) SWIG_fail;
41051 }
41052 {
41053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41054 }
41055 return resultobj;
41056 fail:
41057 return NULL;
41058 }
41059
41060
41061 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41062 PyObject *resultobj = 0;
41063 wxWindow *arg1 = (wxWindow *) 0 ;
41064 bool result;
41065 void *argp1 = 0 ;
41066 int res1 = 0 ;
41067 PyObject *swig_obj[1] ;
41068
41069 if (!args) SWIG_fail;
41070 swig_obj[0] = args;
41071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41072 if (!SWIG_IsOK(res1)) {
41073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
41074 }
41075 arg1 = reinterpret_cast< wxWindow * >(argp1);
41076 {
41077 PyThreadState* __tstate = wxPyBeginAllowThreads();
41078 result = (bool)(arg1)->PageUp();
41079 wxPyEndAllowThreads(__tstate);
41080 if (PyErr_Occurred()) SWIG_fail;
41081 }
41082 {
41083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41084 }
41085 return resultobj;
41086 fail:
41087 return NULL;
41088 }
41089
41090
41091 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41092 PyObject *resultobj = 0;
41093 wxWindow *arg1 = (wxWindow *) 0 ;
41094 bool result;
41095 void *argp1 = 0 ;
41096 int res1 = 0 ;
41097 PyObject *swig_obj[1] ;
41098
41099 if (!args) SWIG_fail;
41100 swig_obj[0] = args;
41101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41102 if (!SWIG_IsOK(res1)) {
41103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41104 }
41105 arg1 = reinterpret_cast< wxWindow * >(argp1);
41106 {
41107 PyThreadState* __tstate = wxPyBeginAllowThreads();
41108 result = (bool)(arg1)->PageDown();
41109 wxPyEndAllowThreads(__tstate);
41110 if (PyErr_Occurred()) SWIG_fail;
41111 }
41112 {
41113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41114 }
41115 return resultobj;
41116 fail:
41117 return NULL;
41118 }
41119
41120
41121 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41122 PyObject *resultobj = 0;
41123 wxWindow *arg1 = (wxWindow *) 0 ;
41124 wxString *arg2 = 0 ;
41125 void *argp1 = 0 ;
41126 int res1 = 0 ;
41127 bool temp2 = false ;
41128 PyObject * obj0 = 0 ;
41129 PyObject * obj1 = 0 ;
41130 char * kwnames[] = {
41131 (char *) "self",(char *) "text", NULL
41132 };
41133
41134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
41135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41136 if (!SWIG_IsOK(res1)) {
41137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
41138 }
41139 arg1 = reinterpret_cast< wxWindow * >(argp1);
41140 {
41141 arg2 = wxString_in_helper(obj1);
41142 if (arg2 == NULL) SWIG_fail;
41143 temp2 = true;
41144 }
41145 {
41146 PyThreadState* __tstate = wxPyBeginAllowThreads();
41147 (arg1)->SetHelpText((wxString const &)*arg2);
41148 wxPyEndAllowThreads(__tstate);
41149 if (PyErr_Occurred()) SWIG_fail;
41150 }
41151 resultobj = SWIG_Py_Void();
41152 {
41153 if (temp2)
41154 delete arg2;
41155 }
41156 return resultobj;
41157 fail:
41158 {
41159 if (temp2)
41160 delete arg2;
41161 }
41162 return NULL;
41163 }
41164
41165
41166 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41167 PyObject *resultobj = 0;
41168 wxWindow *arg1 = (wxWindow *) 0 ;
41169 wxString *arg2 = 0 ;
41170 void *argp1 = 0 ;
41171 int res1 = 0 ;
41172 bool temp2 = false ;
41173 PyObject * obj0 = 0 ;
41174 PyObject * obj1 = 0 ;
41175 char * kwnames[] = {
41176 (char *) "self",(char *) "text", NULL
41177 };
41178
41179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
41180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41181 if (!SWIG_IsOK(res1)) {
41182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
41183 }
41184 arg1 = reinterpret_cast< wxWindow * >(argp1);
41185 {
41186 arg2 = wxString_in_helper(obj1);
41187 if (arg2 == NULL) SWIG_fail;
41188 temp2 = true;
41189 }
41190 {
41191 PyThreadState* __tstate = wxPyBeginAllowThreads();
41192 (arg1)->SetHelpTextForId((wxString const &)*arg2);
41193 wxPyEndAllowThreads(__tstate);
41194 if (PyErr_Occurred()) SWIG_fail;
41195 }
41196 resultobj = SWIG_Py_Void();
41197 {
41198 if (temp2)
41199 delete arg2;
41200 }
41201 return resultobj;
41202 fail:
41203 {
41204 if (temp2)
41205 delete arg2;
41206 }
41207 return NULL;
41208 }
41209
41210
41211 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41212 PyObject *resultobj = 0;
41213 wxWindow *arg1 = (wxWindow *) 0 ;
41214 wxPoint *arg2 = 0 ;
41215 wxHelpEvent::Origin arg3 ;
41216 wxString result;
41217 void *argp1 = 0 ;
41218 int res1 = 0 ;
41219 wxPoint temp2 ;
41220 void *argp3 ;
41221 int res3 = 0 ;
41222 PyObject * obj0 = 0 ;
41223 PyObject * obj1 = 0 ;
41224 PyObject * obj2 = 0 ;
41225 char * kwnames[] = {
41226 (char *) "self",(char *) "pt",(char *) "origin", NULL
41227 };
41228
41229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41231 if (!SWIG_IsOK(res1)) {
41232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
41233 }
41234 arg1 = reinterpret_cast< wxWindow * >(argp1);
41235 {
41236 arg2 = &temp2;
41237 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
41238 }
41239 {
41240 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
41241 if (!SWIG_IsOK(res3)) {
41242 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41243 }
41244 if (!argp3) {
41245 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41246 } else {
41247 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
41248 arg3 = *temp;
41249 if (SWIG_IsNewObj(res3)) delete temp;
41250 }
41251 }
41252 {
41253 PyThreadState* __tstate = wxPyBeginAllowThreads();
41254 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
41255 wxPyEndAllowThreads(__tstate);
41256 if (PyErr_Occurred()) SWIG_fail;
41257 }
41258 {
41259 #if wxUSE_UNICODE
41260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41261 #else
41262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41263 #endif
41264 }
41265 return resultobj;
41266 fail:
41267 return NULL;
41268 }
41269
41270
41271 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41272 PyObject *resultobj = 0;
41273 wxWindow *arg1 = (wxWindow *) 0 ;
41274 wxString result;
41275 void *argp1 = 0 ;
41276 int res1 = 0 ;
41277 PyObject *swig_obj[1] ;
41278
41279 if (!args) SWIG_fail;
41280 swig_obj[0] = args;
41281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41282 if (!SWIG_IsOK(res1)) {
41283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
41284 }
41285 arg1 = reinterpret_cast< wxWindow * >(argp1);
41286 {
41287 PyThreadState* __tstate = wxPyBeginAllowThreads();
41288 result = ((wxWindow const *)arg1)->GetHelpText();
41289 wxPyEndAllowThreads(__tstate);
41290 if (PyErr_Occurred()) SWIG_fail;
41291 }
41292 {
41293 #if wxUSE_UNICODE
41294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41295 #else
41296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41297 #endif
41298 }
41299 return resultobj;
41300 fail:
41301 return NULL;
41302 }
41303
41304
41305 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41306 PyObject *resultobj = 0;
41307 wxWindow *arg1 = (wxWindow *) 0 ;
41308 wxString *arg2 = 0 ;
41309 void *argp1 = 0 ;
41310 int res1 = 0 ;
41311 bool temp2 = false ;
41312 PyObject * obj0 = 0 ;
41313 PyObject * obj1 = 0 ;
41314 char * kwnames[] = {
41315 (char *) "self",(char *) "tip", NULL
41316 };
41317
41318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
41319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41320 if (!SWIG_IsOK(res1)) {
41321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
41322 }
41323 arg1 = reinterpret_cast< wxWindow * >(argp1);
41324 {
41325 arg2 = wxString_in_helper(obj1);
41326 if (arg2 == NULL) SWIG_fail;
41327 temp2 = true;
41328 }
41329 {
41330 PyThreadState* __tstate = wxPyBeginAllowThreads();
41331 (arg1)->SetToolTip((wxString const &)*arg2);
41332 wxPyEndAllowThreads(__tstate);
41333 if (PyErr_Occurred()) SWIG_fail;
41334 }
41335 resultobj = SWIG_Py_Void();
41336 {
41337 if (temp2)
41338 delete arg2;
41339 }
41340 return resultobj;
41341 fail:
41342 {
41343 if (temp2)
41344 delete arg2;
41345 }
41346 return NULL;
41347 }
41348
41349
41350 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41351 PyObject *resultobj = 0;
41352 wxWindow *arg1 = (wxWindow *) 0 ;
41353 wxToolTip *arg2 = (wxToolTip *) 0 ;
41354 void *argp1 = 0 ;
41355 int res1 = 0 ;
41356 int res2 = 0 ;
41357 PyObject * obj0 = 0 ;
41358 PyObject * obj1 = 0 ;
41359 char * kwnames[] = {
41360 (char *) "self",(char *) "tip", NULL
41361 };
41362
41363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
41364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41365 if (!SWIG_IsOK(res1)) {
41366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
41367 }
41368 arg1 = reinterpret_cast< wxWindow * >(argp1);
41369 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
41370 if (!SWIG_IsOK(res2)) {
41371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
41372 }
41373 {
41374 PyThreadState* __tstate = wxPyBeginAllowThreads();
41375 (arg1)->SetToolTip(arg2);
41376 wxPyEndAllowThreads(__tstate);
41377 if (PyErr_Occurred()) SWIG_fail;
41378 }
41379 resultobj = SWIG_Py_Void();
41380 return resultobj;
41381 fail:
41382 return NULL;
41383 }
41384
41385
41386 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41387 PyObject *resultobj = 0;
41388 wxWindow *arg1 = (wxWindow *) 0 ;
41389 wxToolTip *result = 0 ;
41390 void *argp1 = 0 ;
41391 int res1 = 0 ;
41392 PyObject *swig_obj[1] ;
41393
41394 if (!args) SWIG_fail;
41395 swig_obj[0] = args;
41396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41397 if (!SWIG_IsOK(res1)) {
41398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
41399 }
41400 arg1 = reinterpret_cast< wxWindow * >(argp1);
41401 {
41402 PyThreadState* __tstate = wxPyBeginAllowThreads();
41403 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
41404 wxPyEndAllowThreads(__tstate);
41405 if (PyErr_Occurred()) SWIG_fail;
41406 }
41407 {
41408 resultobj = wxPyMake_wxObject(result, (bool)0);
41409 }
41410 return resultobj;
41411 fail:
41412 return NULL;
41413 }
41414
41415
41416 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41417 PyObject *resultobj = 0;
41418 wxWindow *arg1 = (wxWindow *) 0 ;
41419 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
41420 void *argp1 = 0 ;
41421 int res1 = 0 ;
41422 int res2 = 0 ;
41423 PyObject * obj0 = 0 ;
41424 PyObject * obj1 = 0 ;
41425 char * kwnames[] = {
41426 (char *) "self",(char *) "dropTarget", NULL
41427 };
41428
41429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
41430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41431 if (!SWIG_IsOK(res1)) {
41432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
41433 }
41434 arg1 = reinterpret_cast< wxWindow * >(argp1);
41435 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
41436 if (!SWIG_IsOK(res2)) {
41437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
41438 }
41439 {
41440 PyThreadState* __tstate = wxPyBeginAllowThreads();
41441 (arg1)->SetDropTarget(arg2);
41442 wxPyEndAllowThreads(__tstate);
41443 if (PyErr_Occurred()) SWIG_fail;
41444 }
41445 resultobj = SWIG_Py_Void();
41446 return resultobj;
41447 fail:
41448 return NULL;
41449 }
41450
41451
41452 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41453 PyObject *resultobj = 0;
41454 wxWindow *arg1 = (wxWindow *) 0 ;
41455 wxPyDropTarget *result = 0 ;
41456 void *argp1 = 0 ;
41457 int res1 = 0 ;
41458 PyObject *swig_obj[1] ;
41459
41460 if (!args) SWIG_fail;
41461 swig_obj[0] = args;
41462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41463 if (!SWIG_IsOK(res1)) {
41464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
41465 }
41466 arg1 = reinterpret_cast< wxWindow * >(argp1);
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
41474 return resultobj;
41475 fail:
41476 return NULL;
41477 }
41478
41479
41480 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41481 PyObject *resultobj = 0;
41482 wxWindow *arg1 = (wxWindow *) 0 ;
41483 bool arg2 ;
41484 void *argp1 = 0 ;
41485 int res1 = 0 ;
41486 bool val2 ;
41487 int ecode2 = 0 ;
41488 PyObject * obj0 = 0 ;
41489 PyObject * obj1 = 0 ;
41490 char * kwnames[] = {
41491 (char *) "self",(char *) "accept", NULL
41492 };
41493
41494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
41495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41496 if (!SWIG_IsOK(res1)) {
41497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
41498 }
41499 arg1 = reinterpret_cast< wxWindow * >(argp1);
41500 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41501 if (!SWIG_IsOK(ecode2)) {
41502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
41503 }
41504 arg2 = static_cast< bool >(val2);
41505 {
41506 PyThreadState* __tstate = wxPyBeginAllowThreads();
41507 (arg1)->DragAcceptFiles(arg2);
41508 wxPyEndAllowThreads(__tstate);
41509 if (PyErr_Occurred()) SWIG_fail;
41510 }
41511 resultobj = SWIG_Py_Void();
41512 return resultobj;
41513 fail:
41514 return NULL;
41515 }
41516
41517
41518 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41519 PyObject *resultobj = 0;
41520 wxWindow *arg1 = (wxWindow *) 0 ;
41521 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
41522 void *argp1 = 0 ;
41523 int res1 = 0 ;
41524 int res2 = 0 ;
41525 PyObject * obj0 = 0 ;
41526 PyObject * obj1 = 0 ;
41527 char * kwnames[] = {
41528 (char *) "self",(char *) "constraints", NULL
41529 };
41530
41531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
41532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41533 if (!SWIG_IsOK(res1)) {
41534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
41535 }
41536 arg1 = reinterpret_cast< wxWindow * >(argp1);
41537 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
41538 if (!SWIG_IsOK(res2)) {
41539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
41540 }
41541 {
41542 PyThreadState* __tstate = wxPyBeginAllowThreads();
41543 (arg1)->SetConstraints(arg2);
41544 wxPyEndAllowThreads(__tstate);
41545 if (PyErr_Occurred()) SWIG_fail;
41546 }
41547 resultobj = SWIG_Py_Void();
41548 return resultobj;
41549 fail:
41550 return NULL;
41551 }
41552
41553
41554 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41555 PyObject *resultobj = 0;
41556 wxWindow *arg1 = (wxWindow *) 0 ;
41557 wxLayoutConstraints *result = 0 ;
41558 void *argp1 = 0 ;
41559 int res1 = 0 ;
41560 PyObject *swig_obj[1] ;
41561
41562 if (!args) SWIG_fail;
41563 swig_obj[0] = args;
41564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41565 if (!SWIG_IsOK(res1)) {
41566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41567 }
41568 arg1 = reinterpret_cast< wxWindow * >(argp1);
41569 {
41570 PyThreadState* __tstate = wxPyBeginAllowThreads();
41571 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41572 wxPyEndAllowThreads(__tstate);
41573 if (PyErr_Occurred()) SWIG_fail;
41574 }
41575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41576 return resultobj;
41577 fail:
41578 return NULL;
41579 }
41580
41581
41582 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41583 PyObject *resultobj = 0;
41584 wxWindow *arg1 = (wxWindow *) 0 ;
41585 bool arg2 ;
41586 void *argp1 = 0 ;
41587 int res1 = 0 ;
41588 bool val2 ;
41589 int ecode2 = 0 ;
41590 PyObject * obj0 = 0 ;
41591 PyObject * obj1 = 0 ;
41592 char * kwnames[] = {
41593 (char *) "self",(char *) "autoLayout", NULL
41594 };
41595
41596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41598 if (!SWIG_IsOK(res1)) {
41599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41600 }
41601 arg1 = reinterpret_cast< wxWindow * >(argp1);
41602 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41603 if (!SWIG_IsOK(ecode2)) {
41604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41605 }
41606 arg2 = static_cast< bool >(val2);
41607 {
41608 PyThreadState* __tstate = wxPyBeginAllowThreads();
41609 (arg1)->SetAutoLayout(arg2);
41610 wxPyEndAllowThreads(__tstate);
41611 if (PyErr_Occurred()) SWIG_fail;
41612 }
41613 resultobj = SWIG_Py_Void();
41614 return resultobj;
41615 fail:
41616 return NULL;
41617 }
41618
41619
41620 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41621 PyObject *resultobj = 0;
41622 wxWindow *arg1 = (wxWindow *) 0 ;
41623 bool result;
41624 void *argp1 = 0 ;
41625 int res1 = 0 ;
41626 PyObject *swig_obj[1] ;
41627
41628 if (!args) SWIG_fail;
41629 swig_obj[0] = args;
41630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41631 if (!SWIG_IsOK(res1)) {
41632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41633 }
41634 arg1 = reinterpret_cast< wxWindow * >(argp1);
41635 {
41636 PyThreadState* __tstate = wxPyBeginAllowThreads();
41637 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41638 wxPyEndAllowThreads(__tstate);
41639 if (PyErr_Occurred()) SWIG_fail;
41640 }
41641 {
41642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41643 }
41644 return resultobj;
41645 fail:
41646 return NULL;
41647 }
41648
41649
41650 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41651 PyObject *resultobj = 0;
41652 wxWindow *arg1 = (wxWindow *) 0 ;
41653 bool result;
41654 void *argp1 = 0 ;
41655 int res1 = 0 ;
41656 PyObject *swig_obj[1] ;
41657
41658 if (!args) SWIG_fail;
41659 swig_obj[0] = args;
41660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41661 if (!SWIG_IsOK(res1)) {
41662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41663 }
41664 arg1 = reinterpret_cast< wxWindow * >(argp1);
41665 {
41666 PyThreadState* __tstate = wxPyBeginAllowThreads();
41667 result = (bool)(arg1)->Layout();
41668 wxPyEndAllowThreads(__tstate);
41669 if (PyErr_Occurred()) SWIG_fail;
41670 }
41671 {
41672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41673 }
41674 return resultobj;
41675 fail:
41676 return NULL;
41677 }
41678
41679
41680 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41681 PyObject *resultobj = 0;
41682 wxWindow *arg1 = (wxWindow *) 0 ;
41683 wxSizer *arg2 = (wxSizer *) 0 ;
41684 bool arg3 = (bool) true ;
41685 void *argp1 = 0 ;
41686 int res1 = 0 ;
41687 int res2 = 0 ;
41688 bool val3 ;
41689 int ecode3 = 0 ;
41690 PyObject * obj0 = 0 ;
41691 PyObject * obj1 = 0 ;
41692 PyObject * obj2 = 0 ;
41693 char * kwnames[] = {
41694 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41695 };
41696
41697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41699 if (!SWIG_IsOK(res1)) {
41700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41701 }
41702 arg1 = reinterpret_cast< wxWindow * >(argp1);
41703 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41704 if (!SWIG_IsOK(res2)) {
41705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41706 }
41707 if (obj2) {
41708 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41709 if (!SWIG_IsOK(ecode3)) {
41710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41711 }
41712 arg3 = static_cast< bool >(val3);
41713 }
41714 {
41715 PyThreadState* __tstate = wxPyBeginAllowThreads();
41716 (arg1)->SetSizer(arg2,arg3);
41717 wxPyEndAllowThreads(__tstate);
41718 if (PyErr_Occurred()) SWIG_fail;
41719 }
41720 resultobj = SWIG_Py_Void();
41721 return resultobj;
41722 fail:
41723 return NULL;
41724 }
41725
41726
41727 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41728 PyObject *resultobj = 0;
41729 wxWindow *arg1 = (wxWindow *) 0 ;
41730 wxSizer *arg2 = (wxSizer *) 0 ;
41731 bool arg3 = (bool) true ;
41732 void *argp1 = 0 ;
41733 int res1 = 0 ;
41734 int res2 = 0 ;
41735 bool val3 ;
41736 int ecode3 = 0 ;
41737 PyObject * obj0 = 0 ;
41738 PyObject * obj1 = 0 ;
41739 PyObject * obj2 = 0 ;
41740 char * kwnames[] = {
41741 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41742 };
41743
41744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41746 if (!SWIG_IsOK(res1)) {
41747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41748 }
41749 arg1 = reinterpret_cast< wxWindow * >(argp1);
41750 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41751 if (!SWIG_IsOK(res2)) {
41752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41753 }
41754 if (obj2) {
41755 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41756 if (!SWIG_IsOK(ecode3)) {
41757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41758 }
41759 arg3 = static_cast< bool >(val3);
41760 }
41761 {
41762 PyThreadState* __tstate = wxPyBeginAllowThreads();
41763 (arg1)->SetSizerAndFit(arg2,arg3);
41764 wxPyEndAllowThreads(__tstate);
41765 if (PyErr_Occurred()) SWIG_fail;
41766 }
41767 resultobj = SWIG_Py_Void();
41768 return resultobj;
41769 fail:
41770 return NULL;
41771 }
41772
41773
41774 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41775 PyObject *resultobj = 0;
41776 wxWindow *arg1 = (wxWindow *) 0 ;
41777 wxSizer *result = 0 ;
41778 void *argp1 = 0 ;
41779 int res1 = 0 ;
41780 PyObject *swig_obj[1] ;
41781
41782 if (!args) SWIG_fail;
41783 swig_obj[0] = args;
41784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41785 if (!SWIG_IsOK(res1)) {
41786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41787 }
41788 arg1 = reinterpret_cast< wxWindow * >(argp1);
41789 {
41790 PyThreadState* __tstate = wxPyBeginAllowThreads();
41791 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41792 wxPyEndAllowThreads(__tstate);
41793 if (PyErr_Occurred()) SWIG_fail;
41794 }
41795 {
41796 resultobj = wxPyMake_wxObject(result, (bool)0);
41797 }
41798 return resultobj;
41799 fail:
41800 return NULL;
41801 }
41802
41803
41804 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41805 PyObject *resultobj = 0;
41806 wxWindow *arg1 = (wxWindow *) 0 ;
41807 wxSizer *arg2 = (wxSizer *) 0 ;
41808 void *argp1 = 0 ;
41809 int res1 = 0 ;
41810 void *argp2 = 0 ;
41811 int res2 = 0 ;
41812 PyObject * obj0 = 0 ;
41813 PyObject * obj1 = 0 ;
41814 char * kwnames[] = {
41815 (char *) "self",(char *) "sizer", NULL
41816 };
41817
41818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41820 if (!SWIG_IsOK(res1)) {
41821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41822 }
41823 arg1 = reinterpret_cast< wxWindow * >(argp1);
41824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41825 if (!SWIG_IsOK(res2)) {
41826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41827 }
41828 arg2 = reinterpret_cast< wxSizer * >(argp2);
41829 {
41830 PyThreadState* __tstate = wxPyBeginAllowThreads();
41831 (arg1)->SetContainingSizer(arg2);
41832 wxPyEndAllowThreads(__tstate);
41833 if (PyErr_Occurred()) SWIG_fail;
41834 }
41835 resultobj = SWIG_Py_Void();
41836 return resultobj;
41837 fail:
41838 return NULL;
41839 }
41840
41841
41842 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41843 PyObject *resultobj = 0;
41844 wxWindow *arg1 = (wxWindow *) 0 ;
41845 wxSizer *result = 0 ;
41846 void *argp1 = 0 ;
41847 int res1 = 0 ;
41848 PyObject *swig_obj[1] ;
41849
41850 if (!args) SWIG_fail;
41851 swig_obj[0] = args;
41852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41853 if (!SWIG_IsOK(res1)) {
41854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41855 }
41856 arg1 = reinterpret_cast< wxWindow * >(argp1);
41857 {
41858 PyThreadState* __tstate = wxPyBeginAllowThreads();
41859 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41860 wxPyEndAllowThreads(__tstate);
41861 if (PyErr_Occurred()) SWIG_fail;
41862 }
41863 {
41864 resultobj = wxPyMake_wxObject(result, (bool)0);
41865 }
41866 return resultobj;
41867 fail:
41868 return NULL;
41869 }
41870
41871
41872 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41873 PyObject *resultobj = 0;
41874 wxWindow *arg1 = (wxWindow *) 0 ;
41875 void *argp1 = 0 ;
41876 int res1 = 0 ;
41877 PyObject *swig_obj[1] ;
41878
41879 if (!args) SWIG_fail;
41880 swig_obj[0] = args;
41881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41882 if (!SWIG_IsOK(res1)) {
41883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41884 }
41885 arg1 = reinterpret_cast< wxWindow * >(argp1);
41886 {
41887 PyThreadState* __tstate = wxPyBeginAllowThreads();
41888 (arg1)->InheritAttributes();
41889 wxPyEndAllowThreads(__tstate);
41890 if (PyErr_Occurred()) SWIG_fail;
41891 }
41892 resultobj = SWIG_Py_Void();
41893 return resultobj;
41894 fail:
41895 return NULL;
41896 }
41897
41898
41899 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41900 PyObject *resultobj = 0;
41901 wxWindow *arg1 = (wxWindow *) 0 ;
41902 bool result;
41903 void *argp1 = 0 ;
41904 int res1 = 0 ;
41905 PyObject *swig_obj[1] ;
41906
41907 if (!args) SWIG_fail;
41908 swig_obj[0] = args;
41909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41910 if (!SWIG_IsOK(res1)) {
41911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41912 }
41913 arg1 = reinterpret_cast< wxWindow * >(argp1);
41914 {
41915 PyThreadState* __tstate = wxPyBeginAllowThreads();
41916 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41917 wxPyEndAllowThreads(__tstate);
41918 if (PyErr_Occurred()) SWIG_fail;
41919 }
41920 {
41921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41922 }
41923 return resultobj;
41924 fail:
41925 return NULL;
41926 }
41927
41928
41929 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41930 PyObject *resultobj = 0;
41931 wxWindow *arg1 = (wxWindow *) 0 ;
41932 bool result;
41933 void *argp1 = 0 ;
41934 int res1 = 0 ;
41935 PyObject *swig_obj[1] ;
41936
41937 if (!args) SWIG_fail;
41938 swig_obj[0] = args;
41939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41940 if (!SWIG_IsOK(res1)) {
41941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41942 }
41943 arg1 = reinterpret_cast< wxWindow * >(argp1);
41944 {
41945 PyThreadState* __tstate = wxPyBeginAllowThreads();
41946 result = (bool)(arg1)->CanSetTransparent();
41947 wxPyEndAllowThreads(__tstate);
41948 if (PyErr_Occurred()) SWIG_fail;
41949 }
41950 {
41951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41952 }
41953 return resultobj;
41954 fail:
41955 return NULL;
41956 }
41957
41958
41959 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41960 PyObject *resultobj = 0;
41961 wxWindow *arg1 = (wxWindow *) 0 ;
41962 byte arg2 ;
41963 bool result;
41964 void *argp1 = 0 ;
41965 int res1 = 0 ;
41966 unsigned char val2 ;
41967 int ecode2 = 0 ;
41968 PyObject * obj0 = 0 ;
41969 PyObject * obj1 = 0 ;
41970 char * kwnames[] = {
41971 (char *) "self",(char *) "alpha", NULL
41972 };
41973
41974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41976 if (!SWIG_IsOK(res1)) {
41977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41978 }
41979 arg1 = reinterpret_cast< wxWindow * >(argp1);
41980 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41981 if (!SWIG_IsOK(ecode2)) {
41982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41983 }
41984 arg2 = static_cast< byte >(val2);
41985 {
41986 PyThreadState* __tstate = wxPyBeginAllowThreads();
41987 result = (bool)(arg1)->SetTransparent(arg2);
41988 wxPyEndAllowThreads(__tstate);
41989 if (PyErr_Occurred()) SWIG_fail;
41990 }
41991 {
41992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41993 }
41994 return resultobj;
41995 fail:
41996 return NULL;
41997 }
41998
41999
42000 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42001 PyObject *obj;
42002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42003 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
42004 return SWIG_Py_Void();
42005 }
42006
42007 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42008 return SWIG_Python_InitShadowInstance(args);
42009 }
42010
42011 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42012 PyObject *resultobj = 0;
42013 long arg1 ;
42014 wxWindow *arg2 = (wxWindow *) NULL ;
42015 wxWindow *result = 0 ;
42016 long val1 ;
42017 int ecode1 = 0 ;
42018 void *argp2 = 0 ;
42019 int res2 = 0 ;
42020 PyObject * obj0 = 0 ;
42021 PyObject * obj1 = 0 ;
42022 char * kwnames[] = {
42023 (char *) "id",(char *) "parent", NULL
42024 };
42025
42026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
42027 ecode1 = SWIG_AsVal_long(obj0, &val1);
42028 if (!SWIG_IsOK(ecode1)) {
42029 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
42030 }
42031 arg1 = static_cast< long >(val1);
42032 if (obj1) {
42033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42034 if (!SWIG_IsOK(res2)) {
42035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
42036 }
42037 arg2 = reinterpret_cast< wxWindow * >(argp2);
42038 }
42039 {
42040 if (!wxPyCheckForApp()) SWIG_fail;
42041 PyThreadState* __tstate = wxPyBeginAllowThreads();
42042 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
42043 wxPyEndAllowThreads(__tstate);
42044 if (PyErr_Occurred()) SWIG_fail;
42045 }
42046 {
42047 resultobj = wxPyMake_wxObject(result, 0);
42048 }
42049 return resultobj;
42050 fail:
42051 return NULL;
42052 }
42053
42054
42055 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42056 PyObject *resultobj = 0;
42057 wxString *arg1 = 0 ;
42058 wxWindow *arg2 = (wxWindow *) NULL ;
42059 wxWindow *result = 0 ;
42060 bool temp1 = false ;
42061 void *argp2 = 0 ;
42062 int res2 = 0 ;
42063 PyObject * obj0 = 0 ;
42064 PyObject * obj1 = 0 ;
42065 char * kwnames[] = {
42066 (char *) "name",(char *) "parent", NULL
42067 };
42068
42069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
42070 {
42071 arg1 = wxString_in_helper(obj0);
42072 if (arg1 == NULL) SWIG_fail;
42073 temp1 = true;
42074 }
42075 if (obj1) {
42076 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42077 if (!SWIG_IsOK(res2)) {
42078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
42079 }
42080 arg2 = reinterpret_cast< wxWindow * >(argp2);
42081 }
42082 {
42083 if (!wxPyCheckForApp()) SWIG_fail;
42084 PyThreadState* __tstate = wxPyBeginAllowThreads();
42085 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
42086 wxPyEndAllowThreads(__tstate);
42087 if (PyErr_Occurred()) SWIG_fail;
42088 }
42089 {
42090 resultobj = wxPyMake_wxObject(result, 0);
42091 }
42092 {
42093 if (temp1)
42094 delete arg1;
42095 }
42096 return resultobj;
42097 fail:
42098 {
42099 if (temp1)
42100 delete arg1;
42101 }
42102 return NULL;
42103 }
42104
42105
42106 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42107 PyObject *resultobj = 0;
42108 wxString *arg1 = 0 ;
42109 wxWindow *arg2 = (wxWindow *) NULL ;
42110 wxWindow *result = 0 ;
42111 bool temp1 = false ;
42112 void *argp2 = 0 ;
42113 int res2 = 0 ;
42114 PyObject * obj0 = 0 ;
42115 PyObject * obj1 = 0 ;
42116 char * kwnames[] = {
42117 (char *) "label",(char *) "parent", NULL
42118 };
42119
42120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42121 {
42122 arg1 = wxString_in_helper(obj0);
42123 if (arg1 == NULL) SWIG_fail;
42124 temp1 = true;
42125 }
42126 if (obj1) {
42127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42128 if (!SWIG_IsOK(res2)) {
42129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
42130 }
42131 arg2 = reinterpret_cast< wxWindow * >(argp2);
42132 }
42133 {
42134 if (!wxPyCheckForApp()) SWIG_fail;
42135 PyThreadState* __tstate = wxPyBeginAllowThreads();
42136 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
42137 wxPyEndAllowThreads(__tstate);
42138 if (PyErr_Occurred()) SWIG_fail;
42139 }
42140 {
42141 resultobj = wxPyMake_wxObject(result, 0);
42142 }
42143 {
42144 if (temp1)
42145 delete arg1;
42146 }
42147 return resultobj;
42148 fail:
42149 {
42150 if (temp1)
42151 delete arg1;
42152 }
42153 return NULL;
42154 }
42155
42156
42157 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42158 PyObject *resultobj = 0;
42159 wxWindow *arg1 = (wxWindow *) 0 ;
42160 unsigned long arg2 ;
42161 wxWindow *result = 0 ;
42162 void *argp1 = 0 ;
42163 int res1 = 0 ;
42164 unsigned long val2 ;
42165 int ecode2 = 0 ;
42166 PyObject * obj0 = 0 ;
42167 PyObject * obj1 = 0 ;
42168 char * kwnames[] = {
42169 (char *) "parent",(char *) "_hWnd", NULL
42170 };
42171
42172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
42173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
42174 if (!SWIG_IsOK(res1)) {
42175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
42176 }
42177 arg1 = reinterpret_cast< wxWindow * >(argp1);
42178 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
42179 if (!SWIG_IsOK(ecode2)) {
42180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
42181 }
42182 arg2 = static_cast< unsigned long >(val2);
42183 {
42184 if (!wxPyCheckForApp()) SWIG_fail;
42185 PyThreadState* __tstate = wxPyBeginAllowThreads();
42186 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
42187 wxPyEndAllowThreads(__tstate);
42188 if (PyErr_Occurred()) SWIG_fail;
42189 }
42190 {
42191 resultobj = wxPyMake_wxObject(result, 0);
42192 }
42193 return resultobj;
42194 fail:
42195 return NULL;
42196 }
42197
42198
42199 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42200 PyObject *resultobj = 0;
42201 PyObject *result = 0 ;
42202
42203 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
42204 {
42205 PyThreadState* __tstate = wxPyBeginAllowThreads();
42206 result = (PyObject *)GetTopLevelWindows();
42207 wxPyEndAllowThreads(__tstate);
42208 if (PyErr_Occurred()) SWIG_fail;
42209 }
42210 resultobj = result;
42211 return resultobj;
42212 fail:
42213 return NULL;
42214 }
42215
42216
42217 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42218 PyObject *resultobj = 0;
42219 wxValidator *result = 0 ;
42220
42221 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
42222 {
42223 PyThreadState* __tstate = wxPyBeginAllowThreads();
42224 result = (wxValidator *)new wxValidator();
42225 wxPyEndAllowThreads(__tstate);
42226 if (PyErr_Occurred()) SWIG_fail;
42227 }
42228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
42229 return resultobj;
42230 fail:
42231 return NULL;
42232 }
42233
42234
42235 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42236 PyObject *resultobj = 0;
42237 wxValidator *arg1 = (wxValidator *) 0 ;
42238 wxValidator *result = 0 ;
42239 void *argp1 = 0 ;
42240 int res1 = 0 ;
42241 PyObject *swig_obj[1] ;
42242
42243 if (!args) SWIG_fail;
42244 swig_obj[0] = args;
42245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42246 if (!SWIG_IsOK(res1)) {
42247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
42248 }
42249 arg1 = reinterpret_cast< wxValidator * >(argp1);
42250 {
42251 PyThreadState* __tstate = wxPyBeginAllowThreads();
42252 result = (wxValidator *)(arg1)->Clone();
42253 wxPyEndAllowThreads(__tstate);
42254 if (PyErr_Occurred()) SWIG_fail;
42255 }
42256 {
42257 resultobj = wxPyMake_wxObject(result, 0);
42258 }
42259 return resultobj;
42260 fail:
42261 return NULL;
42262 }
42263
42264
42265 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42266 PyObject *resultobj = 0;
42267 wxValidator *arg1 = (wxValidator *) 0 ;
42268 wxWindow *arg2 = (wxWindow *) 0 ;
42269 bool result;
42270 void *argp1 = 0 ;
42271 int res1 = 0 ;
42272 void *argp2 = 0 ;
42273 int res2 = 0 ;
42274 PyObject * obj0 = 0 ;
42275 PyObject * obj1 = 0 ;
42276 char * kwnames[] = {
42277 (char *) "self",(char *) "parent", NULL
42278 };
42279
42280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
42281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42282 if (!SWIG_IsOK(res1)) {
42283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
42284 }
42285 arg1 = reinterpret_cast< wxValidator * >(argp1);
42286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42287 if (!SWIG_IsOK(res2)) {
42288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
42289 }
42290 arg2 = reinterpret_cast< wxWindow * >(argp2);
42291 {
42292 PyThreadState* __tstate = wxPyBeginAllowThreads();
42293 result = (bool)(arg1)->Validate(arg2);
42294 wxPyEndAllowThreads(__tstate);
42295 if (PyErr_Occurred()) SWIG_fail;
42296 }
42297 {
42298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42299 }
42300 return resultobj;
42301 fail:
42302 return NULL;
42303 }
42304
42305
42306 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42307 PyObject *resultobj = 0;
42308 wxValidator *arg1 = (wxValidator *) 0 ;
42309 bool result;
42310 void *argp1 = 0 ;
42311 int res1 = 0 ;
42312 PyObject *swig_obj[1] ;
42313
42314 if (!args) SWIG_fail;
42315 swig_obj[0] = args;
42316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42317 if (!SWIG_IsOK(res1)) {
42318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42319 }
42320 arg1 = reinterpret_cast< wxValidator * >(argp1);
42321 {
42322 PyThreadState* __tstate = wxPyBeginAllowThreads();
42323 result = (bool)(arg1)->TransferToWindow();
42324 wxPyEndAllowThreads(__tstate);
42325 if (PyErr_Occurred()) SWIG_fail;
42326 }
42327 {
42328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42329 }
42330 return resultobj;
42331 fail:
42332 return NULL;
42333 }
42334
42335
42336 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42337 PyObject *resultobj = 0;
42338 wxValidator *arg1 = (wxValidator *) 0 ;
42339 bool result;
42340 void *argp1 = 0 ;
42341 int res1 = 0 ;
42342 PyObject *swig_obj[1] ;
42343
42344 if (!args) SWIG_fail;
42345 swig_obj[0] = args;
42346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42347 if (!SWIG_IsOK(res1)) {
42348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42349 }
42350 arg1 = reinterpret_cast< wxValidator * >(argp1);
42351 {
42352 PyThreadState* __tstate = wxPyBeginAllowThreads();
42353 result = (bool)(arg1)->TransferFromWindow();
42354 wxPyEndAllowThreads(__tstate);
42355 if (PyErr_Occurred()) SWIG_fail;
42356 }
42357 {
42358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42359 }
42360 return resultobj;
42361 fail:
42362 return NULL;
42363 }
42364
42365
42366 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42367 PyObject *resultobj = 0;
42368 wxValidator *arg1 = (wxValidator *) 0 ;
42369 wxWindow *result = 0 ;
42370 void *argp1 = 0 ;
42371 int res1 = 0 ;
42372 PyObject *swig_obj[1] ;
42373
42374 if (!args) SWIG_fail;
42375 swig_obj[0] = args;
42376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42377 if (!SWIG_IsOK(res1)) {
42378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42379 }
42380 arg1 = reinterpret_cast< wxValidator * >(argp1);
42381 {
42382 PyThreadState* __tstate = wxPyBeginAllowThreads();
42383 result = (wxWindow *)(arg1)->GetWindow();
42384 wxPyEndAllowThreads(__tstate);
42385 if (PyErr_Occurred()) SWIG_fail;
42386 }
42387 {
42388 resultobj = wxPyMake_wxObject(result, 0);
42389 }
42390 return resultobj;
42391 fail:
42392 return NULL;
42393 }
42394
42395
42396 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42397 PyObject *resultobj = 0;
42398 wxValidator *arg1 = (wxValidator *) 0 ;
42399 wxWindow *arg2 = (wxWindow *) 0 ;
42400 void *argp1 = 0 ;
42401 int res1 = 0 ;
42402 void *argp2 = 0 ;
42403 int res2 = 0 ;
42404 PyObject * obj0 = 0 ;
42405 PyObject * obj1 = 0 ;
42406 char * kwnames[] = {
42407 (char *) "self",(char *) "window", NULL
42408 };
42409
42410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
42411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42412 if (!SWIG_IsOK(res1)) {
42413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42414 }
42415 arg1 = reinterpret_cast< wxValidator * >(argp1);
42416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42417 if (!SWIG_IsOK(res2)) {
42418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
42419 }
42420 arg2 = reinterpret_cast< wxWindow * >(argp2);
42421 {
42422 PyThreadState* __tstate = wxPyBeginAllowThreads();
42423 (arg1)->SetWindow(arg2);
42424 wxPyEndAllowThreads(__tstate);
42425 if (PyErr_Occurred()) SWIG_fail;
42426 }
42427 resultobj = SWIG_Py_Void();
42428 return resultobj;
42429 fail:
42430 return NULL;
42431 }
42432
42433
42434 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42435 PyObject *resultobj = 0;
42436 bool result;
42437
42438 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
42439 {
42440 PyThreadState* __tstate = wxPyBeginAllowThreads();
42441 result = (bool)wxValidator::IsSilent();
42442 wxPyEndAllowThreads(__tstate);
42443 if (PyErr_Occurred()) SWIG_fail;
42444 }
42445 {
42446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42447 }
42448 return resultobj;
42449 fail:
42450 return NULL;
42451 }
42452
42453
42454 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42455 PyObject *resultobj = 0;
42456 int arg1 = (int) true ;
42457 int val1 ;
42458 int ecode1 = 0 ;
42459 PyObject * obj0 = 0 ;
42460 char * kwnames[] = {
42461 (char *) "doIt", NULL
42462 };
42463
42464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
42465 if (obj0) {
42466 ecode1 = SWIG_AsVal_int(obj0, &val1);
42467 if (!SWIG_IsOK(ecode1)) {
42468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
42469 }
42470 arg1 = static_cast< int >(val1);
42471 }
42472 {
42473 PyThreadState* __tstate = wxPyBeginAllowThreads();
42474 wxValidator::SetBellOnError(arg1);
42475 wxPyEndAllowThreads(__tstate);
42476 if (PyErr_Occurred()) SWIG_fail;
42477 }
42478 resultobj = SWIG_Py_Void();
42479 return resultobj;
42480 fail:
42481 return NULL;
42482 }
42483
42484
42485 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42486 PyObject *obj;
42487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42488 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
42489 return SWIG_Py_Void();
42490 }
42491
42492 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42493 return SWIG_Python_InitShadowInstance(args);
42494 }
42495
42496 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42497 PyObject *resultobj = 0;
42498 wxPyValidator *result = 0 ;
42499
42500 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
42501 {
42502 PyThreadState* __tstate = wxPyBeginAllowThreads();
42503 result = (wxPyValidator *)new wxPyValidator();
42504 wxPyEndAllowThreads(__tstate);
42505 if (PyErr_Occurred()) SWIG_fail;
42506 }
42507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
42508 return resultobj;
42509 fail:
42510 return NULL;
42511 }
42512
42513
42514 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42515 PyObject *resultobj = 0;
42516 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
42517 PyObject *arg2 = (PyObject *) 0 ;
42518 PyObject *arg3 = (PyObject *) 0 ;
42519 int arg4 = (int) 1 ;
42520 void *argp1 = 0 ;
42521 int res1 = 0 ;
42522 int val4 ;
42523 int ecode4 = 0 ;
42524 PyObject * obj0 = 0 ;
42525 PyObject * obj1 = 0 ;
42526 PyObject * obj2 = 0 ;
42527 PyObject * obj3 = 0 ;
42528 char * kwnames[] = {
42529 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
42530 };
42531
42532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
42534 if (!SWIG_IsOK(res1)) {
42535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
42536 }
42537 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
42538 arg2 = obj1;
42539 arg3 = obj2;
42540 if (obj3) {
42541 ecode4 = SWIG_AsVal_int(obj3, &val4);
42542 if (!SWIG_IsOK(ecode4)) {
42543 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
42544 }
42545 arg4 = static_cast< int >(val4);
42546 }
42547 {
42548 PyThreadState* __tstate = wxPyBeginAllowThreads();
42549 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
42550 wxPyEndAllowThreads(__tstate);
42551 if (PyErr_Occurred()) SWIG_fail;
42552 }
42553 resultobj = SWIG_Py_Void();
42554 return resultobj;
42555 fail:
42556 return NULL;
42557 }
42558
42559
42560 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42561 PyObject *obj;
42562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42563 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
42564 return SWIG_Py_Void();
42565 }
42566
42567 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42568 return SWIG_Python_InitShadowInstance(args);
42569 }
42570
42571 SWIGINTERN int DefaultValidator_set(PyObject *) {
42572 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42573 return 1;
42574 }
42575
42576
42577 SWIGINTERN PyObject *DefaultValidator_get(void) {
42578 PyObject *pyobj = 0;
42579
42580 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42581 return pyobj;
42582 }
42583
42584
42585 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42586 PyObject *resultobj = 0;
42587 wxString const &arg1_defvalue = wxPyEmptyString ;
42588 wxString *arg1 = (wxString *) &arg1_defvalue ;
42589 long arg2 = (long) 0 ;
42590 wxMenu *result = 0 ;
42591 bool temp1 = false ;
42592 long val2 ;
42593 int ecode2 = 0 ;
42594 PyObject * obj0 = 0 ;
42595 PyObject * obj1 = 0 ;
42596 char * kwnames[] = {
42597 (char *) "title",(char *) "style", NULL
42598 };
42599
42600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42601 if (obj0) {
42602 {
42603 arg1 = wxString_in_helper(obj0);
42604 if (arg1 == NULL) SWIG_fail;
42605 temp1 = true;
42606 }
42607 }
42608 if (obj1) {
42609 ecode2 = SWIG_AsVal_long(obj1, &val2);
42610 if (!SWIG_IsOK(ecode2)) {
42611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42612 }
42613 arg2 = static_cast< long >(val2);
42614 }
42615 {
42616 if (!wxPyCheckForApp()) SWIG_fail;
42617 PyThreadState* __tstate = wxPyBeginAllowThreads();
42618 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42619 wxPyEndAllowThreads(__tstate);
42620 if (PyErr_Occurred()) SWIG_fail;
42621 }
42622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42623 {
42624 if (temp1)
42625 delete arg1;
42626 }
42627 return resultobj;
42628 fail:
42629 {
42630 if (temp1)
42631 delete arg1;
42632 }
42633 return NULL;
42634 }
42635
42636
42637 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42638 PyObject *resultobj = 0;
42639 wxMenu *arg1 = (wxMenu *) 0 ;
42640 int arg2 ;
42641 wxString const &arg3_defvalue = wxPyEmptyString ;
42642 wxString *arg3 = (wxString *) &arg3_defvalue ;
42643 wxString const &arg4_defvalue = wxPyEmptyString ;
42644 wxString *arg4 = (wxString *) &arg4_defvalue ;
42645 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42646 wxMenuItem *result = 0 ;
42647 void *argp1 = 0 ;
42648 int res1 = 0 ;
42649 int val2 ;
42650 int ecode2 = 0 ;
42651 bool temp3 = false ;
42652 bool temp4 = false ;
42653 int val5 ;
42654 int ecode5 = 0 ;
42655 PyObject * obj0 = 0 ;
42656 PyObject * obj1 = 0 ;
42657 PyObject * obj2 = 0 ;
42658 PyObject * obj3 = 0 ;
42659 PyObject * obj4 = 0 ;
42660 char * kwnames[] = {
42661 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42662 };
42663
42664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42666 if (!SWIG_IsOK(res1)) {
42667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42668 }
42669 arg1 = reinterpret_cast< wxMenu * >(argp1);
42670 ecode2 = SWIG_AsVal_int(obj1, &val2);
42671 if (!SWIG_IsOK(ecode2)) {
42672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42673 }
42674 arg2 = static_cast< int >(val2);
42675 if (obj2) {
42676 {
42677 arg3 = wxString_in_helper(obj2);
42678 if (arg3 == NULL) SWIG_fail;
42679 temp3 = true;
42680 }
42681 }
42682 if (obj3) {
42683 {
42684 arg4 = wxString_in_helper(obj3);
42685 if (arg4 == NULL) SWIG_fail;
42686 temp4 = true;
42687 }
42688 }
42689 if (obj4) {
42690 ecode5 = SWIG_AsVal_int(obj4, &val5);
42691 if (!SWIG_IsOK(ecode5)) {
42692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42693 }
42694 arg5 = static_cast< wxItemKind >(val5);
42695 }
42696 {
42697 PyThreadState* __tstate = wxPyBeginAllowThreads();
42698 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42699 wxPyEndAllowThreads(__tstate);
42700 if (PyErr_Occurred()) SWIG_fail;
42701 }
42702 {
42703 resultobj = wxPyMake_wxObject(result, (bool)0);
42704 }
42705 {
42706 if (temp3)
42707 delete arg3;
42708 }
42709 {
42710 if (temp4)
42711 delete arg4;
42712 }
42713 return resultobj;
42714 fail:
42715 {
42716 if (temp3)
42717 delete arg3;
42718 }
42719 {
42720 if (temp4)
42721 delete arg4;
42722 }
42723 return NULL;
42724 }
42725
42726
42727 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42728 PyObject *resultobj = 0;
42729 wxMenu *arg1 = (wxMenu *) 0 ;
42730 wxMenuItem *result = 0 ;
42731 void *argp1 = 0 ;
42732 int res1 = 0 ;
42733 PyObject *swig_obj[1] ;
42734
42735 if (!args) SWIG_fail;
42736 swig_obj[0] = args;
42737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42738 if (!SWIG_IsOK(res1)) {
42739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42740 }
42741 arg1 = reinterpret_cast< wxMenu * >(argp1);
42742 {
42743 PyThreadState* __tstate = wxPyBeginAllowThreads();
42744 result = (wxMenuItem *)(arg1)->AppendSeparator();
42745 wxPyEndAllowThreads(__tstate);
42746 if (PyErr_Occurred()) SWIG_fail;
42747 }
42748 {
42749 resultobj = wxPyMake_wxObject(result, (bool)0);
42750 }
42751 return resultobj;
42752 fail:
42753 return NULL;
42754 }
42755
42756
42757 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42758 PyObject *resultobj = 0;
42759 wxMenu *arg1 = (wxMenu *) 0 ;
42760 int arg2 ;
42761 wxString *arg3 = 0 ;
42762 wxString const &arg4_defvalue = wxPyEmptyString ;
42763 wxString *arg4 = (wxString *) &arg4_defvalue ;
42764 wxMenuItem *result = 0 ;
42765 void *argp1 = 0 ;
42766 int res1 = 0 ;
42767 int val2 ;
42768 int ecode2 = 0 ;
42769 bool temp3 = false ;
42770 bool temp4 = false ;
42771 PyObject * obj0 = 0 ;
42772 PyObject * obj1 = 0 ;
42773 PyObject * obj2 = 0 ;
42774 PyObject * obj3 = 0 ;
42775 char * kwnames[] = {
42776 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42777 };
42778
42779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42781 if (!SWIG_IsOK(res1)) {
42782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42783 }
42784 arg1 = reinterpret_cast< wxMenu * >(argp1);
42785 ecode2 = SWIG_AsVal_int(obj1, &val2);
42786 if (!SWIG_IsOK(ecode2)) {
42787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42788 }
42789 arg2 = static_cast< int >(val2);
42790 {
42791 arg3 = wxString_in_helper(obj2);
42792 if (arg3 == NULL) SWIG_fail;
42793 temp3 = true;
42794 }
42795 if (obj3) {
42796 {
42797 arg4 = wxString_in_helper(obj3);
42798 if (arg4 == NULL) SWIG_fail;
42799 temp4 = true;
42800 }
42801 }
42802 {
42803 PyThreadState* __tstate = wxPyBeginAllowThreads();
42804 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42805 wxPyEndAllowThreads(__tstate);
42806 if (PyErr_Occurred()) SWIG_fail;
42807 }
42808 {
42809 resultobj = wxPyMake_wxObject(result, (bool)0);
42810 }
42811 {
42812 if (temp3)
42813 delete arg3;
42814 }
42815 {
42816 if (temp4)
42817 delete arg4;
42818 }
42819 return resultobj;
42820 fail:
42821 {
42822 if (temp3)
42823 delete arg3;
42824 }
42825 {
42826 if (temp4)
42827 delete arg4;
42828 }
42829 return NULL;
42830 }
42831
42832
42833 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42834 PyObject *resultobj = 0;
42835 wxMenu *arg1 = (wxMenu *) 0 ;
42836 int arg2 ;
42837 wxString *arg3 = 0 ;
42838 wxString const &arg4_defvalue = wxPyEmptyString ;
42839 wxString *arg4 = (wxString *) &arg4_defvalue ;
42840 wxMenuItem *result = 0 ;
42841 void *argp1 = 0 ;
42842 int res1 = 0 ;
42843 int val2 ;
42844 int ecode2 = 0 ;
42845 bool temp3 = false ;
42846 bool temp4 = false ;
42847 PyObject * obj0 = 0 ;
42848 PyObject * obj1 = 0 ;
42849 PyObject * obj2 = 0 ;
42850 PyObject * obj3 = 0 ;
42851 char * kwnames[] = {
42852 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42853 };
42854
42855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42857 if (!SWIG_IsOK(res1)) {
42858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42859 }
42860 arg1 = reinterpret_cast< wxMenu * >(argp1);
42861 ecode2 = SWIG_AsVal_int(obj1, &val2);
42862 if (!SWIG_IsOK(ecode2)) {
42863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42864 }
42865 arg2 = static_cast< int >(val2);
42866 {
42867 arg3 = wxString_in_helper(obj2);
42868 if (arg3 == NULL) SWIG_fail;
42869 temp3 = true;
42870 }
42871 if (obj3) {
42872 {
42873 arg4 = wxString_in_helper(obj3);
42874 if (arg4 == NULL) SWIG_fail;
42875 temp4 = true;
42876 }
42877 }
42878 {
42879 PyThreadState* __tstate = wxPyBeginAllowThreads();
42880 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42881 wxPyEndAllowThreads(__tstate);
42882 if (PyErr_Occurred()) SWIG_fail;
42883 }
42884 {
42885 resultobj = wxPyMake_wxObject(result, (bool)0);
42886 }
42887 {
42888 if (temp3)
42889 delete arg3;
42890 }
42891 {
42892 if (temp4)
42893 delete arg4;
42894 }
42895 return resultobj;
42896 fail:
42897 {
42898 if (temp3)
42899 delete arg3;
42900 }
42901 {
42902 if (temp4)
42903 delete arg4;
42904 }
42905 return NULL;
42906 }
42907
42908
42909 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42910 PyObject *resultobj = 0;
42911 wxMenu *arg1 = (wxMenu *) 0 ;
42912 int arg2 ;
42913 wxString *arg3 = 0 ;
42914 wxMenu *arg4 = (wxMenu *) 0 ;
42915 wxString const &arg5_defvalue = wxPyEmptyString ;
42916 wxString *arg5 = (wxString *) &arg5_defvalue ;
42917 wxMenuItem *result = 0 ;
42918 void *argp1 = 0 ;
42919 int res1 = 0 ;
42920 int val2 ;
42921 int ecode2 = 0 ;
42922 bool temp3 = false ;
42923 void *argp4 = 0 ;
42924 int res4 = 0 ;
42925 bool temp5 = false ;
42926 PyObject * obj0 = 0 ;
42927 PyObject * obj1 = 0 ;
42928 PyObject * obj2 = 0 ;
42929 PyObject * obj3 = 0 ;
42930 PyObject * obj4 = 0 ;
42931 char * kwnames[] = {
42932 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42933 };
42934
42935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42937 if (!SWIG_IsOK(res1)) {
42938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42939 }
42940 arg1 = reinterpret_cast< wxMenu * >(argp1);
42941 ecode2 = SWIG_AsVal_int(obj1, &val2);
42942 if (!SWIG_IsOK(ecode2)) {
42943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42944 }
42945 arg2 = static_cast< int >(val2);
42946 {
42947 arg3 = wxString_in_helper(obj2);
42948 if (arg3 == NULL) SWIG_fail;
42949 temp3 = true;
42950 }
42951 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42952 if (!SWIG_IsOK(res4)) {
42953 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42954 }
42955 arg4 = reinterpret_cast< wxMenu * >(argp4);
42956 if (obj4) {
42957 {
42958 arg5 = wxString_in_helper(obj4);
42959 if (arg5 == NULL) SWIG_fail;
42960 temp5 = true;
42961 }
42962 }
42963 {
42964 PyThreadState* __tstate = wxPyBeginAllowThreads();
42965 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42966 wxPyEndAllowThreads(__tstate);
42967 if (PyErr_Occurred()) SWIG_fail;
42968 }
42969 {
42970 resultobj = wxPyMake_wxObject(result, (bool)0);
42971 }
42972 {
42973 if (temp3)
42974 delete arg3;
42975 }
42976 {
42977 if (temp5)
42978 delete arg5;
42979 }
42980 return resultobj;
42981 fail:
42982 {
42983 if (temp3)
42984 delete arg3;
42985 }
42986 {
42987 if (temp5)
42988 delete arg5;
42989 }
42990 return NULL;
42991 }
42992
42993
42994 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42995 PyObject *resultobj = 0;
42996 wxMenu *arg1 = (wxMenu *) 0 ;
42997 wxMenu *arg2 = (wxMenu *) 0 ;
42998 wxString *arg3 = 0 ;
42999 wxString const &arg4_defvalue = wxPyEmptyString ;
43000 wxString *arg4 = (wxString *) &arg4_defvalue ;
43001 wxMenuItem *result = 0 ;
43002 void *argp1 = 0 ;
43003 int res1 = 0 ;
43004 void *argp2 = 0 ;
43005 int res2 = 0 ;
43006 bool temp3 = false ;
43007 bool temp4 = false ;
43008 PyObject * obj0 = 0 ;
43009 PyObject * obj1 = 0 ;
43010 PyObject * obj2 = 0 ;
43011 PyObject * obj3 = 0 ;
43012 char * kwnames[] = {
43013 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
43014 };
43015
43016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43018 if (!SWIG_IsOK(res1)) {
43019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43020 }
43021 arg1 = reinterpret_cast< wxMenu * >(argp1);
43022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43023 if (!SWIG_IsOK(res2)) {
43024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43025 }
43026 arg2 = reinterpret_cast< wxMenu * >(argp2);
43027 {
43028 arg3 = wxString_in_helper(obj2);
43029 if (arg3 == NULL) SWIG_fail;
43030 temp3 = true;
43031 }
43032 if (obj3) {
43033 {
43034 arg4 = wxString_in_helper(obj3);
43035 if (arg4 == NULL) SWIG_fail;
43036 temp4 = true;
43037 }
43038 }
43039 {
43040 PyThreadState* __tstate = wxPyBeginAllowThreads();
43041 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43042 wxPyEndAllowThreads(__tstate);
43043 if (PyErr_Occurred()) SWIG_fail;
43044 }
43045 {
43046 resultobj = wxPyMake_wxObject(result, (bool)0);
43047 }
43048 {
43049 if (temp3)
43050 delete arg3;
43051 }
43052 {
43053 if (temp4)
43054 delete arg4;
43055 }
43056 return resultobj;
43057 fail:
43058 {
43059 if (temp3)
43060 delete arg3;
43061 }
43062 {
43063 if (temp4)
43064 delete arg4;
43065 }
43066 return NULL;
43067 }
43068
43069
43070 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43071 PyObject *resultobj = 0;
43072 wxMenu *arg1 = (wxMenu *) 0 ;
43073 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43074 wxMenuItem *result = 0 ;
43075 void *argp1 = 0 ;
43076 int res1 = 0 ;
43077 int res2 = 0 ;
43078 PyObject * obj0 = 0 ;
43079 PyObject * obj1 = 0 ;
43080 char * kwnames[] = {
43081 (char *) "self",(char *) "item", NULL
43082 };
43083
43084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
43085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43086 if (!SWIG_IsOK(res1)) {
43087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43088 }
43089 arg1 = reinterpret_cast< wxMenu * >(argp1);
43090 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43091 if (!SWIG_IsOK(res2)) {
43092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43093 }
43094 {
43095 PyThreadState* __tstate = wxPyBeginAllowThreads();
43096 result = (wxMenuItem *)(arg1)->Append(arg2);
43097 wxPyEndAllowThreads(__tstate);
43098 if (PyErr_Occurred()) SWIG_fail;
43099 }
43100 {
43101 resultobj = wxPyMake_wxObject(result, (bool)0);
43102 }
43103 return resultobj;
43104 fail:
43105 return NULL;
43106 }
43107
43108
43109 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43110 PyObject *resultobj = 0;
43111 wxMenu *arg1 = (wxMenu *) 0 ;
43112 size_t arg2 ;
43113 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
43114 wxMenuItem *result = 0 ;
43115 void *argp1 = 0 ;
43116 int res1 = 0 ;
43117 size_t val2 ;
43118 int ecode2 = 0 ;
43119 int res3 = 0 ;
43120 PyObject * obj0 = 0 ;
43121 PyObject * obj1 = 0 ;
43122 PyObject * obj2 = 0 ;
43123 char * kwnames[] = {
43124 (char *) "self",(char *) "pos",(char *) "item", NULL
43125 };
43126
43127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43129 if (!SWIG_IsOK(res1)) {
43130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43131 }
43132 arg1 = reinterpret_cast< wxMenu * >(argp1);
43133 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43134 if (!SWIG_IsOK(ecode2)) {
43135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
43136 }
43137 arg2 = static_cast< size_t >(val2);
43138 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43139 if (!SWIG_IsOK(res3)) {
43140 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
43141 }
43142 {
43143 PyThreadState* __tstate = wxPyBeginAllowThreads();
43144 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
43145 wxPyEndAllowThreads(__tstate);
43146 if (PyErr_Occurred()) SWIG_fail;
43147 }
43148 {
43149 resultobj = wxPyMake_wxObject(result, (bool)0);
43150 }
43151 return resultobj;
43152 fail:
43153 return NULL;
43154 }
43155
43156
43157 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43158 PyObject *resultobj = 0;
43159 wxMenu *arg1 = (wxMenu *) 0 ;
43160 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43161 wxMenuItem *result = 0 ;
43162 void *argp1 = 0 ;
43163 int res1 = 0 ;
43164 int res2 = 0 ;
43165 PyObject * obj0 = 0 ;
43166 PyObject * obj1 = 0 ;
43167 char * kwnames[] = {
43168 (char *) "self",(char *) "item", NULL
43169 };
43170
43171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
43172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43173 if (!SWIG_IsOK(res1)) {
43174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43175 }
43176 arg1 = reinterpret_cast< wxMenu * >(argp1);
43177 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43178 if (!SWIG_IsOK(res2)) {
43179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43180 }
43181 {
43182 PyThreadState* __tstate = wxPyBeginAllowThreads();
43183 result = (wxMenuItem *)(arg1)->Prepend(arg2);
43184 wxPyEndAllowThreads(__tstate);
43185 if (PyErr_Occurred()) SWIG_fail;
43186 }
43187 {
43188 resultobj = wxPyMake_wxObject(result, (bool)0);
43189 }
43190 return resultobj;
43191 fail:
43192 return NULL;
43193 }
43194
43195
43196 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43197 PyObject *resultobj = 0;
43198 wxMenu *arg1 = (wxMenu *) 0 ;
43199 void *argp1 = 0 ;
43200 int res1 = 0 ;
43201 PyObject *swig_obj[1] ;
43202
43203 if (!args) SWIG_fail;
43204 swig_obj[0] = args;
43205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43206 if (!SWIG_IsOK(res1)) {
43207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
43208 }
43209 arg1 = reinterpret_cast< wxMenu * >(argp1);
43210 {
43211 PyThreadState* __tstate = wxPyBeginAllowThreads();
43212 (arg1)->Break();
43213 wxPyEndAllowThreads(__tstate);
43214 if (PyErr_Occurred()) SWIG_fail;
43215 }
43216 resultobj = SWIG_Py_Void();
43217 return resultobj;
43218 fail:
43219 return NULL;
43220 }
43221
43222
43223 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43224 PyObject *resultobj = 0;
43225 wxMenu *arg1 = (wxMenu *) 0 ;
43226 size_t arg2 ;
43227 int arg3 ;
43228 wxString const &arg4_defvalue = wxPyEmptyString ;
43229 wxString *arg4 = (wxString *) &arg4_defvalue ;
43230 wxString const &arg5_defvalue = wxPyEmptyString ;
43231 wxString *arg5 = (wxString *) &arg5_defvalue ;
43232 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
43233 wxMenuItem *result = 0 ;
43234 void *argp1 = 0 ;
43235 int res1 = 0 ;
43236 size_t val2 ;
43237 int ecode2 = 0 ;
43238 int val3 ;
43239 int ecode3 = 0 ;
43240 bool temp4 = false ;
43241 bool temp5 = false ;
43242 int val6 ;
43243 int ecode6 = 0 ;
43244 PyObject * obj0 = 0 ;
43245 PyObject * obj1 = 0 ;
43246 PyObject * obj2 = 0 ;
43247 PyObject * obj3 = 0 ;
43248 PyObject * obj4 = 0 ;
43249 PyObject * obj5 = 0 ;
43250 char * kwnames[] = {
43251 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43252 };
43253
43254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43256 if (!SWIG_IsOK(res1)) {
43257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
43258 }
43259 arg1 = reinterpret_cast< wxMenu * >(argp1);
43260 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43261 if (!SWIG_IsOK(ecode2)) {
43262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
43263 }
43264 arg2 = static_cast< size_t >(val2);
43265 ecode3 = SWIG_AsVal_int(obj2, &val3);
43266 if (!SWIG_IsOK(ecode3)) {
43267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
43268 }
43269 arg3 = static_cast< int >(val3);
43270 if (obj3) {
43271 {
43272 arg4 = wxString_in_helper(obj3);
43273 if (arg4 == NULL) SWIG_fail;
43274 temp4 = true;
43275 }
43276 }
43277 if (obj4) {
43278 {
43279 arg5 = wxString_in_helper(obj4);
43280 if (arg5 == NULL) SWIG_fail;
43281 temp5 = true;
43282 }
43283 }
43284 if (obj5) {
43285 ecode6 = SWIG_AsVal_int(obj5, &val6);
43286 if (!SWIG_IsOK(ecode6)) {
43287 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
43288 }
43289 arg6 = static_cast< wxItemKind >(val6);
43290 }
43291 {
43292 PyThreadState* __tstate = wxPyBeginAllowThreads();
43293 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
43294 wxPyEndAllowThreads(__tstate);
43295 if (PyErr_Occurred()) SWIG_fail;
43296 }
43297 {
43298 resultobj = wxPyMake_wxObject(result, (bool)0);
43299 }
43300 {
43301 if (temp4)
43302 delete arg4;
43303 }
43304 {
43305 if (temp5)
43306 delete arg5;
43307 }
43308 return resultobj;
43309 fail:
43310 {
43311 if (temp4)
43312 delete arg4;
43313 }
43314 {
43315 if (temp5)
43316 delete arg5;
43317 }
43318 return NULL;
43319 }
43320
43321
43322 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43323 PyObject *resultobj = 0;
43324 wxMenu *arg1 = (wxMenu *) 0 ;
43325 size_t arg2 ;
43326 wxMenuItem *result = 0 ;
43327 void *argp1 = 0 ;
43328 int res1 = 0 ;
43329 size_t val2 ;
43330 int ecode2 = 0 ;
43331 PyObject * obj0 = 0 ;
43332 PyObject * obj1 = 0 ;
43333 char * kwnames[] = {
43334 (char *) "self",(char *) "pos", NULL
43335 };
43336
43337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
43338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43339 if (!SWIG_IsOK(res1)) {
43340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43341 }
43342 arg1 = reinterpret_cast< wxMenu * >(argp1);
43343 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43344 if (!SWIG_IsOK(ecode2)) {
43345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
43346 }
43347 arg2 = static_cast< size_t >(val2);
43348 {
43349 PyThreadState* __tstate = wxPyBeginAllowThreads();
43350 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
43351 wxPyEndAllowThreads(__tstate);
43352 if (PyErr_Occurred()) SWIG_fail;
43353 }
43354 {
43355 resultobj = wxPyMake_wxObject(result, (bool)0);
43356 }
43357 return resultobj;
43358 fail:
43359 return NULL;
43360 }
43361
43362
43363 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43364 PyObject *resultobj = 0;
43365 wxMenu *arg1 = (wxMenu *) 0 ;
43366 size_t arg2 ;
43367 int arg3 ;
43368 wxString *arg4 = 0 ;
43369 wxString const &arg5_defvalue = wxPyEmptyString ;
43370 wxString *arg5 = (wxString *) &arg5_defvalue ;
43371 wxMenuItem *result = 0 ;
43372 void *argp1 = 0 ;
43373 int res1 = 0 ;
43374 size_t val2 ;
43375 int ecode2 = 0 ;
43376 int val3 ;
43377 int ecode3 = 0 ;
43378 bool temp4 = false ;
43379 bool temp5 = false ;
43380 PyObject * obj0 = 0 ;
43381 PyObject * obj1 = 0 ;
43382 PyObject * obj2 = 0 ;
43383 PyObject * obj3 = 0 ;
43384 PyObject * obj4 = 0 ;
43385 char * kwnames[] = {
43386 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43387 };
43388
43389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43391 if (!SWIG_IsOK(res1)) {
43392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43393 }
43394 arg1 = reinterpret_cast< wxMenu * >(argp1);
43395 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43396 if (!SWIG_IsOK(ecode2)) {
43397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
43398 }
43399 arg2 = static_cast< size_t >(val2);
43400 ecode3 = SWIG_AsVal_int(obj2, &val3);
43401 if (!SWIG_IsOK(ecode3)) {
43402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
43403 }
43404 arg3 = static_cast< int >(val3);
43405 {
43406 arg4 = wxString_in_helper(obj3);
43407 if (arg4 == NULL) SWIG_fail;
43408 temp4 = true;
43409 }
43410 if (obj4) {
43411 {
43412 arg5 = wxString_in_helper(obj4);
43413 if (arg5 == NULL) SWIG_fail;
43414 temp5 = true;
43415 }
43416 }
43417 {
43418 PyThreadState* __tstate = wxPyBeginAllowThreads();
43419 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43420 wxPyEndAllowThreads(__tstate);
43421 if (PyErr_Occurred()) SWIG_fail;
43422 }
43423 {
43424 resultobj = wxPyMake_wxObject(result, (bool)0);
43425 }
43426 {
43427 if (temp4)
43428 delete arg4;
43429 }
43430 {
43431 if (temp5)
43432 delete arg5;
43433 }
43434 return resultobj;
43435 fail:
43436 {
43437 if (temp4)
43438 delete arg4;
43439 }
43440 {
43441 if (temp5)
43442 delete arg5;
43443 }
43444 return NULL;
43445 }
43446
43447
43448 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43449 PyObject *resultobj = 0;
43450 wxMenu *arg1 = (wxMenu *) 0 ;
43451 size_t arg2 ;
43452 int arg3 ;
43453 wxString *arg4 = 0 ;
43454 wxString const &arg5_defvalue = wxPyEmptyString ;
43455 wxString *arg5 = (wxString *) &arg5_defvalue ;
43456 wxMenuItem *result = 0 ;
43457 void *argp1 = 0 ;
43458 int res1 = 0 ;
43459 size_t val2 ;
43460 int ecode2 = 0 ;
43461 int val3 ;
43462 int ecode3 = 0 ;
43463 bool temp4 = false ;
43464 bool temp5 = false ;
43465 PyObject * obj0 = 0 ;
43466 PyObject * obj1 = 0 ;
43467 PyObject * obj2 = 0 ;
43468 PyObject * obj3 = 0 ;
43469 PyObject * obj4 = 0 ;
43470 char * kwnames[] = {
43471 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43472 };
43473
43474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43476 if (!SWIG_IsOK(res1)) {
43477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43478 }
43479 arg1 = reinterpret_cast< wxMenu * >(argp1);
43480 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43481 if (!SWIG_IsOK(ecode2)) {
43482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
43483 }
43484 arg2 = static_cast< size_t >(val2);
43485 ecode3 = SWIG_AsVal_int(obj2, &val3);
43486 if (!SWIG_IsOK(ecode3)) {
43487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
43488 }
43489 arg3 = static_cast< int >(val3);
43490 {
43491 arg4 = wxString_in_helper(obj3);
43492 if (arg4 == NULL) SWIG_fail;
43493 temp4 = true;
43494 }
43495 if (obj4) {
43496 {
43497 arg5 = wxString_in_helper(obj4);
43498 if (arg5 == NULL) SWIG_fail;
43499 temp5 = true;
43500 }
43501 }
43502 {
43503 PyThreadState* __tstate = wxPyBeginAllowThreads();
43504 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43505 wxPyEndAllowThreads(__tstate);
43506 if (PyErr_Occurred()) SWIG_fail;
43507 }
43508 {
43509 resultobj = wxPyMake_wxObject(result, (bool)0);
43510 }
43511 {
43512 if (temp4)
43513 delete arg4;
43514 }
43515 {
43516 if (temp5)
43517 delete arg5;
43518 }
43519 return resultobj;
43520 fail:
43521 {
43522 if (temp4)
43523 delete arg4;
43524 }
43525 {
43526 if (temp5)
43527 delete arg5;
43528 }
43529 return NULL;
43530 }
43531
43532
43533 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43534 PyObject *resultobj = 0;
43535 wxMenu *arg1 = (wxMenu *) 0 ;
43536 size_t arg2 ;
43537 int arg3 ;
43538 wxString *arg4 = 0 ;
43539 wxMenu *arg5 = (wxMenu *) 0 ;
43540 wxString const &arg6_defvalue = wxPyEmptyString ;
43541 wxString *arg6 = (wxString *) &arg6_defvalue ;
43542 wxMenuItem *result = 0 ;
43543 void *argp1 = 0 ;
43544 int res1 = 0 ;
43545 size_t val2 ;
43546 int ecode2 = 0 ;
43547 int val3 ;
43548 int ecode3 = 0 ;
43549 bool temp4 = false ;
43550 void *argp5 = 0 ;
43551 int res5 = 0 ;
43552 bool temp6 = false ;
43553 PyObject * obj0 = 0 ;
43554 PyObject * obj1 = 0 ;
43555 PyObject * obj2 = 0 ;
43556 PyObject * obj3 = 0 ;
43557 PyObject * obj4 = 0 ;
43558 PyObject * obj5 = 0 ;
43559 char * kwnames[] = {
43560 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43561 };
43562
43563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43565 if (!SWIG_IsOK(res1)) {
43566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43567 }
43568 arg1 = reinterpret_cast< wxMenu * >(argp1);
43569 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43570 if (!SWIG_IsOK(ecode2)) {
43571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43572 }
43573 arg2 = static_cast< size_t >(val2);
43574 ecode3 = SWIG_AsVal_int(obj2, &val3);
43575 if (!SWIG_IsOK(ecode3)) {
43576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43577 }
43578 arg3 = static_cast< int >(val3);
43579 {
43580 arg4 = wxString_in_helper(obj3);
43581 if (arg4 == NULL) SWIG_fail;
43582 temp4 = true;
43583 }
43584 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43585 if (!SWIG_IsOK(res5)) {
43586 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43587 }
43588 arg5 = reinterpret_cast< wxMenu * >(argp5);
43589 if (obj5) {
43590 {
43591 arg6 = wxString_in_helper(obj5);
43592 if (arg6 == NULL) SWIG_fail;
43593 temp6 = true;
43594 }
43595 }
43596 {
43597 PyThreadState* __tstate = wxPyBeginAllowThreads();
43598 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43599 wxPyEndAllowThreads(__tstate);
43600 if (PyErr_Occurred()) SWIG_fail;
43601 }
43602 {
43603 resultobj = wxPyMake_wxObject(result, (bool)0);
43604 }
43605 {
43606 if (temp4)
43607 delete arg4;
43608 }
43609 {
43610 if (temp6)
43611 delete arg6;
43612 }
43613 return resultobj;
43614 fail:
43615 {
43616 if (temp4)
43617 delete arg4;
43618 }
43619 {
43620 if (temp6)
43621 delete arg6;
43622 }
43623 return NULL;
43624 }
43625
43626
43627 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43628 PyObject *resultobj = 0;
43629 wxMenu *arg1 = (wxMenu *) 0 ;
43630 int arg2 ;
43631 wxString const &arg3_defvalue = wxPyEmptyString ;
43632 wxString *arg3 = (wxString *) &arg3_defvalue ;
43633 wxString const &arg4_defvalue = wxPyEmptyString ;
43634 wxString *arg4 = (wxString *) &arg4_defvalue ;
43635 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43636 wxMenuItem *result = 0 ;
43637 void *argp1 = 0 ;
43638 int res1 = 0 ;
43639 int val2 ;
43640 int ecode2 = 0 ;
43641 bool temp3 = false ;
43642 bool temp4 = false ;
43643 int val5 ;
43644 int ecode5 = 0 ;
43645 PyObject * obj0 = 0 ;
43646 PyObject * obj1 = 0 ;
43647 PyObject * obj2 = 0 ;
43648 PyObject * obj3 = 0 ;
43649 PyObject * obj4 = 0 ;
43650 char * kwnames[] = {
43651 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43652 };
43653
43654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43656 if (!SWIG_IsOK(res1)) {
43657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43658 }
43659 arg1 = reinterpret_cast< wxMenu * >(argp1);
43660 ecode2 = SWIG_AsVal_int(obj1, &val2);
43661 if (!SWIG_IsOK(ecode2)) {
43662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43663 }
43664 arg2 = static_cast< int >(val2);
43665 if (obj2) {
43666 {
43667 arg3 = wxString_in_helper(obj2);
43668 if (arg3 == NULL) SWIG_fail;
43669 temp3 = true;
43670 }
43671 }
43672 if (obj3) {
43673 {
43674 arg4 = wxString_in_helper(obj3);
43675 if (arg4 == NULL) SWIG_fail;
43676 temp4 = true;
43677 }
43678 }
43679 if (obj4) {
43680 ecode5 = SWIG_AsVal_int(obj4, &val5);
43681 if (!SWIG_IsOK(ecode5)) {
43682 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43683 }
43684 arg5 = static_cast< wxItemKind >(val5);
43685 }
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43689 wxPyEndAllowThreads(__tstate);
43690 if (PyErr_Occurred()) SWIG_fail;
43691 }
43692 {
43693 resultobj = wxPyMake_wxObject(result, (bool)0);
43694 }
43695 {
43696 if (temp3)
43697 delete arg3;
43698 }
43699 {
43700 if (temp4)
43701 delete arg4;
43702 }
43703 return resultobj;
43704 fail:
43705 {
43706 if (temp3)
43707 delete arg3;
43708 }
43709 {
43710 if (temp4)
43711 delete arg4;
43712 }
43713 return NULL;
43714 }
43715
43716
43717 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43718 PyObject *resultobj = 0;
43719 wxMenu *arg1 = (wxMenu *) 0 ;
43720 wxMenuItem *result = 0 ;
43721 void *argp1 = 0 ;
43722 int res1 = 0 ;
43723 PyObject *swig_obj[1] ;
43724
43725 if (!args) SWIG_fail;
43726 swig_obj[0] = args;
43727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43728 if (!SWIG_IsOK(res1)) {
43729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43730 }
43731 arg1 = reinterpret_cast< wxMenu * >(argp1);
43732 {
43733 PyThreadState* __tstate = wxPyBeginAllowThreads();
43734 result = (wxMenuItem *)(arg1)->PrependSeparator();
43735 wxPyEndAllowThreads(__tstate);
43736 if (PyErr_Occurred()) SWIG_fail;
43737 }
43738 {
43739 resultobj = wxPyMake_wxObject(result, (bool)0);
43740 }
43741 return resultobj;
43742 fail:
43743 return NULL;
43744 }
43745
43746
43747 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43748 PyObject *resultobj = 0;
43749 wxMenu *arg1 = (wxMenu *) 0 ;
43750 int arg2 ;
43751 wxString *arg3 = 0 ;
43752 wxString const &arg4_defvalue = wxPyEmptyString ;
43753 wxString *arg4 = (wxString *) &arg4_defvalue ;
43754 wxMenuItem *result = 0 ;
43755 void *argp1 = 0 ;
43756 int res1 = 0 ;
43757 int val2 ;
43758 int ecode2 = 0 ;
43759 bool temp3 = false ;
43760 bool temp4 = false ;
43761 PyObject * obj0 = 0 ;
43762 PyObject * obj1 = 0 ;
43763 PyObject * obj2 = 0 ;
43764 PyObject * obj3 = 0 ;
43765 char * kwnames[] = {
43766 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43767 };
43768
43769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43771 if (!SWIG_IsOK(res1)) {
43772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43773 }
43774 arg1 = reinterpret_cast< wxMenu * >(argp1);
43775 ecode2 = SWIG_AsVal_int(obj1, &val2);
43776 if (!SWIG_IsOK(ecode2)) {
43777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43778 }
43779 arg2 = static_cast< int >(val2);
43780 {
43781 arg3 = wxString_in_helper(obj2);
43782 if (arg3 == NULL) SWIG_fail;
43783 temp3 = true;
43784 }
43785 if (obj3) {
43786 {
43787 arg4 = wxString_in_helper(obj3);
43788 if (arg4 == NULL) SWIG_fail;
43789 temp4 = true;
43790 }
43791 }
43792 {
43793 PyThreadState* __tstate = wxPyBeginAllowThreads();
43794 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43795 wxPyEndAllowThreads(__tstate);
43796 if (PyErr_Occurred()) SWIG_fail;
43797 }
43798 {
43799 resultobj = wxPyMake_wxObject(result, (bool)0);
43800 }
43801 {
43802 if (temp3)
43803 delete arg3;
43804 }
43805 {
43806 if (temp4)
43807 delete arg4;
43808 }
43809 return resultobj;
43810 fail:
43811 {
43812 if (temp3)
43813 delete arg3;
43814 }
43815 {
43816 if (temp4)
43817 delete arg4;
43818 }
43819 return NULL;
43820 }
43821
43822
43823 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43824 PyObject *resultobj = 0;
43825 wxMenu *arg1 = (wxMenu *) 0 ;
43826 int arg2 ;
43827 wxString *arg3 = 0 ;
43828 wxString const &arg4_defvalue = wxPyEmptyString ;
43829 wxString *arg4 = (wxString *) &arg4_defvalue ;
43830 wxMenuItem *result = 0 ;
43831 void *argp1 = 0 ;
43832 int res1 = 0 ;
43833 int val2 ;
43834 int ecode2 = 0 ;
43835 bool temp3 = false ;
43836 bool temp4 = false ;
43837 PyObject * obj0 = 0 ;
43838 PyObject * obj1 = 0 ;
43839 PyObject * obj2 = 0 ;
43840 PyObject * obj3 = 0 ;
43841 char * kwnames[] = {
43842 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43843 };
43844
43845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43847 if (!SWIG_IsOK(res1)) {
43848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43849 }
43850 arg1 = reinterpret_cast< wxMenu * >(argp1);
43851 ecode2 = SWIG_AsVal_int(obj1, &val2);
43852 if (!SWIG_IsOK(ecode2)) {
43853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43854 }
43855 arg2 = static_cast< int >(val2);
43856 {
43857 arg3 = wxString_in_helper(obj2);
43858 if (arg3 == NULL) SWIG_fail;
43859 temp3 = true;
43860 }
43861 if (obj3) {
43862 {
43863 arg4 = wxString_in_helper(obj3);
43864 if (arg4 == NULL) SWIG_fail;
43865 temp4 = true;
43866 }
43867 }
43868 {
43869 PyThreadState* __tstate = wxPyBeginAllowThreads();
43870 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43871 wxPyEndAllowThreads(__tstate);
43872 if (PyErr_Occurred()) SWIG_fail;
43873 }
43874 {
43875 resultobj = wxPyMake_wxObject(result, (bool)0);
43876 }
43877 {
43878 if (temp3)
43879 delete arg3;
43880 }
43881 {
43882 if (temp4)
43883 delete arg4;
43884 }
43885 return resultobj;
43886 fail:
43887 {
43888 if (temp3)
43889 delete arg3;
43890 }
43891 {
43892 if (temp4)
43893 delete arg4;
43894 }
43895 return NULL;
43896 }
43897
43898
43899 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43900 PyObject *resultobj = 0;
43901 wxMenu *arg1 = (wxMenu *) 0 ;
43902 int arg2 ;
43903 wxString *arg3 = 0 ;
43904 wxMenu *arg4 = (wxMenu *) 0 ;
43905 wxString const &arg5_defvalue = wxPyEmptyString ;
43906 wxString *arg5 = (wxString *) &arg5_defvalue ;
43907 wxMenuItem *result = 0 ;
43908 void *argp1 = 0 ;
43909 int res1 = 0 ;
43910 int val2 ;
43911 int ecode2 = 0 ;
43912 bool temp3 = false ;
43913 void *argp4 = 0 ;
43914 int res4 = 0 ;
43915 bool temp5 = false ;
43916 PyObject * obj0 = 0 ;
43917 PyObject * obj1 = 0 ;
43918 PyObject * obj2 = 0 ;
43919 PyObject * obj3 = 0 ;
43920 PyObject * obj4 = 0 ;
43921 char * kwnames[] = {
43922 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43923 };
43924
43925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43927 if (!SWIG_IsOK(res1)) {
43928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43929 }
43930 arg1 = reinterpret_cast< wxMenu * >(argp1);
43931 ecode2 = SWIG_AsVal_int(obj1, &val2);
43932 if (!SWIG_IsOK(ecode2)) {
43933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43934 }
43935 arg2 = static_cast< int >(val2);
43936 {
43937 arg3 = wxString_in_helper(obj2);
43938 if (arg3 == NULL) SWIG_fail;
43939 temp3 = true;
43940 }
43941 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43942 if (!SWIG_IsOK(res4)) {
43943 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43944 }
43945 arg4 = reinterpret_cast< wxMenu * >(argp4);
43946 if (obj4) {
43947 {
43948 arg5 = wxString_in_helper(obj4);
43949 if (arg5 == NULL) SWIG_fail;
43950 temp5 = true;
43951 }
43952 }
43953 {
43954 PyThreadState* __tstate = wxPyBeginAllowThreads();
43955 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43956 wxPyEndAllowThreads(__tstate);
43957 if (PyErr_Occurred()) SWIG_fail;
43958 }
43959 {
43960 resultobj = wxPyMake_wxObject(result, (bool)0);
43961 }
43962 {
43963 if (temp3)
43964 delete arg3;
43965 }
43966 {
43967 if (temp5)
43968 delete arg5;
43969 }
43970 return resultobj;
43971 fail:
43972 {
43973 if (temp3)
43974 delete arg3;
43975 }
43976 {
43977 if (temp5)
43978 delete arg5;
43979 }
43980 return NULL;
43981 }
43982
43983
43984 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43985 PyObject *resultobj = 0;
43986 wxMenu *arg1 = (wxMenu *) 0 ;
43987 int arg2 ;
43988 wxMenuItem *result = 0 ;
43989 void *argp1 = 0 ;
43990 int res1 = 0 ;
43991 int val2 ;
43992 int ecode2 = 0 ;
43993 PyObject * obj0 = 0 ;
43994 PyObject * obj1 = 0 ;
43995 char * kwnames[] = {
43996 (char *) "self",(char *) "id", NULL
43997 };
43998
43999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44001 if (!SWIG_IsOK(res1)) {
44002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
44003 }
44004 arg1 = reinterpret_cast< wxMenu * >(argp1);
44005 ecode2 = SWIG_AsVal_int(obj1, &val2);
44006 if (!SWIG_IsOK(ecode2)) {
44007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
44008 }
44009 arg2 = static_cast< int >(val2);
44010 {
44011 PyThreadState* __tstate = wxPyBeginAllowThreads();
44012 result = (wxMenuItem *)(arg1)->Remove(arg2);
44013 wxPyEndAllowThreads(__tstate);
44014 if (PyErr_Occurred()) SWIG_fail;
44015 }
44016 {
44017 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
44018 }
44019 return resultobj;
44020 fail:
44021 return NULL;
44022 }
44023
44024
44025 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44026 PyObject *resultobj = 0;
44027 wxMenu *arg1 = (wxMenu *) 0 ;
44028 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44029 wxMenuItem *result = 0 ;
44030 void *argp1 = 0 ;
44031 int res1 = 0 ;
44032 void *argp2 = 0 ;
44033 int res2 = 0 ;
44034 PyObject * obj0 = 0 ;
44035 PyObject * obj1 = 0 ;
44036 char * kwnames[] = {
44037 (char *) "self",(char *) "item", NULL
44038 };
44039
44040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
44041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44042 if (!SWIG_IsOK(res1)) {
44043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44044 }
44045 arg1 = reinterpret_cast< wxMenu * >(argp1);
44046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44047 if (!SWIG_IsOK(res2)) {
44048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44049 }
44050 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44051 {
44052 PyThreadState* __tstate = wxPyBeginAllowThreads();
44053 result = (wxMenuItem *)(arg1)->Remove(arg2);
44054 wxPyEndAllowThreads(__tstate);
44055 if (PyErr_Occurred()) SWIG_fail;
44056 }
44057 {
44058 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
44059 }
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44067 PyObject *resultobj = 0;
44068 wxMenu *arg1 = (wxMenu *) 0 ;
44069 int arg2 ;
44070 bool result;
44071 void *argp1 = 0 ;
44072 int res1 = 0 ;
44073 int val2 ;
44074 int ecode2 = 0 ;
44075 PyObject * obj0 = 0 ;
44076 PyObject * obj1 = 0 ;
44077 char * kwnames[] = {
44078 (char *) "self",(char *) "id", NULL
44079 };
44080
44081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44083 if (!SWIG_IsOK(res1)) {
44084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
44085 }
44086 arg1 = reinterpret_cast< wxMenu * >(argp1);
44087 ecode2 = SWIG_AsVal_int(obj1, &val2);
44088 if (!SWIG_IsOK(ecode2)) {
44089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
44090 }
44091 arg2 = static_cast< int >(val2);
44092 {
44093 PyThreadState* __tstate = wxPyBeginAllowThreads();
44094 result = (bool)(arg1)->Delete(arg2);
44095 wxPyEndAllowThreads(__tstate);
44096 if (PyErr_Occurred()) SWIG_fail;
44097 }
44098 {
44099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44100 }
44101 return resultobj;
44102 fail:
44103 return NULL;
44104 }
44105
44106
44107 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44108 PyObject *resultobj = 0;
44109 wxMenu *arg1 = (wxMenu *) 0 ;
44110 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44111 bool result;
44112 void *argp1 = 0 ;
44113 int res1 = 0 ;
44114 void *argp2 = 0 ;
44115 int res2 = 0 ;
44116 PyObject * obj0 = 0 ;
44117 PyObject * obj1 = 0 ;
44118 char * kwnames[] = {
44119 (char *) "self",(char *) "item", NULL
44120 };
44121
44122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
44123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44124 if (!SWIG_IsOK(res1)) {
44125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44126 }
44127 arg1 = reinterpret_cast< wxMenu * >(argp1);
44128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44129 if (!SWIG_IsOK(res2)) {
44130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44131 }
44132 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44133 {
44134 PyThreadState* __tstate = wxPyBeginAllowThreads();
44135 result = (bool)(arg1)->Delete(arg2);
44136 wxPyEndAllowThreads(__tstate);
44137 if (PyErr_Occurred()) SWIG_fail;
44138 }
44139 {
44140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44141 }
44142 return resultobj;
44143 fail:
44144 return NULL;
44145 }
44146
44147
44148 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44149 PyObject *resultobj = 0;
44150 wxMenu *arg1 = (wxMenu *) 0 ;
44151 void *argp1 = 0 ;
44152 int res1 = 0 ;
44153 PyObject *swig_obj[1] ;
44154
44155 if (!args) SWIG_fail;
44156 swig_obj[0] = args;
44157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44158 if (!SWIG_IsOK(res1)) {
44159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
44160 }
44161 arg1 = reinterpret_cast< wxMenu * >(argp1);
44162 {
44163 PyThreadState* __tstate = wxPyBeginAllowThreads();
44164 wxMenu_Destroy(arg1);
44165 wxPyEndAllowThreads(__tstate);
44166 if (PyErr_Occurred()) SWIG_fail;
44167 }
44168 resultobj = SWIG_Py_Void();
44169 return resultobj;
44170 fail:
44171 return NULL;
44172 }
44173
44174
44175 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44176 PyObject *resultobj = 0;
44177 wxMenu *arg1 = (wxMenu *) 0 ;
44178 int arg2 ;
44179 bool result;
44180 void *argp1 = 0 ;
44181 int res1 = 0 ;
44182 int val2 ;
44183 int ecode2 = 0 ;
44184 PyObject * obj0 = 0 ;
44185 PyObject * obj1 = 0 ;
44186 char * kwnames[] = {
44187 (char *) "self",(char *) "id", NULL
44188 };
44189
44190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
44191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44192 if (!SWIG_IsOK(res1)) {
44193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
44194 }
44195 arg1 = reinterpret_cast< wxMenu * >(argp1);
44196 ecode2 = SWIG_AsVal_int(obj1, &val2);
44197 if (!SWIG_IsOK(ecode2)) {
44198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
44199 }
44200 arg2 = static_cast< int >(val2);
44201 {
44202 PyThreadState* __tstate = wxPyBeginAllowThreads();
44203 result = (bool)(arg1)->Destroy(arg2);
44204 wxPyEndAllowThreads(__tstate);
44205 if (PyErr_Occurred()) SWIG_fail;
44206 }
44207 {
44208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44209 }
44210 return resultobj;
44211 fail:
44212 return NULL;
44213 }
44214
44215
44216 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44217 PyObject *resultobj = 0;
44218 wxMenu *arg1 = (wxMenu *) 0 ;
44219 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44220 bool result;
44221 void *argp1 = 0 ;
44222 int res1 = 0 ;
44223 void *argp2 = 0 ;
44224 int res2 = 0 ;
44225 PyObject * obj0 = 0 ;
44226 PyObject * obj1 = 0 ;
44227 char * kwnames[] = {
44228 (char *) "self",(char *) "item", NULL
44229 };
44230
44231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
44232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44233 if (!SWIG_IsOK(res1)) {
44234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44235 }
44236 arg1 = reinterpret_cast< wxMenu * >(argp1);
44237 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44238 if (!SWIG_IsOK(res2)) {
44239 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44240 }
44241 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44242 {
44243 PyThreadState* __tstate = wxPyBeginAllowThreads();
44244 result = (bool)(arg1)->Destroy(arg2);
44245 wxPyEndAllowThreads(__tstate);
44246 if (PyErr_Occurred()) SWIG_fail;
44247 }
44248 {
44249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44250 }
44251 return resultobj;
44252 fail:
44253 return NULL;
44254 }
44255
44256
44257 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44258 PyObject *resultobj = 0;
44259 wxMenu *arg1 = (wxMenu *) 0 ;
44260 size_t result;
44261 void *argp1 = 0 ;
44262 int res1 = 0 ;
44263 PyObject *swig_obj[1] ;
44264
44265 if (!args) SWIG_fail;
44266 swig_obj[0] = args;
44267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44268 if (!SWIG_IsOK(res1)) {
44269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
44270 }
44271 arg1 = reinterpret_cast< wxMenu * >(argp1);
44272 {
44273 PyThreadState* __tstate = wxPyBeginAllowThreads();
44274 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
44275 wxPyEndAllowThreads(__tstate);
44276 if (PyErr_Occurred()) SWIG_fail;
44277 }
44278 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44279 return resultobj;
44280 fail:
44281 return NULL;
44282 }
44283
44284
44285 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44286 PyObject *resultobj = 0;
44287 wxMenu *arg1 = (wxMenu *) 0 ;
44288 PyObject *result = 0 ;
44289 void *argp1 = 0 ;
44290 int res1 = 0 ;
44291 PyObject *swig_obj[1] ;
44292
44293 if (!args) SWIG_fail;
44294 swig_obj[0] = args;
44295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44296 if (!SWIG_IsOK(res1)) {
44297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
44298 }
44299 arg1 = reinterpret_cast< wxMenu * >(argp1);
44300 {
44301 PyThreadState* __tstate = wxPyBeginAllowThreads();
44302 result = (PyObject *)wxMenu_GetMenuItems(arg1);
44303 wxPyEndAllowThreads(__tstate);
44304 if (PyErr_Occurred()) SWIG_fail;
44305 }
44306 resultobj = result;
44307 return resultobj;
44308 fail:
44309 return NULL;
44310 }
44311
44312
44313 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44314 PyObject *resultobj = 0;
44315 wxMenu *arg1 = (wxMenu *) 0 ;
44316 wxString *arg2 = 0 ;
44317 int result;
44318 void *argp1 = 0 ;
44319 int res1 = 0 ;
44320 bool temp2 = false ;
44321 PyObject * obj0 = 0 ;
44322 PyObject * obj1 = 0 ;
44323 char * kwnames[] = {
44324 (char *) "self",(char *) "item", NULL
44325 };
44326
44327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
44328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44329 if (!SWIG_IsOK(res1)) {
44330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
44331 }
44332 arg1 = reinterpret_cast< wxMenu * >(argp1);
44333 {
44334 arg2 = wxString_in_helper(obj1);
44335 if (arg2 == NULL) SWIG_fail;
44336 temp2 = true;
44337 }
44338 {
44339 PyThreadState* __tstate = wxPyBeginAllowThreads();
44340 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
44341 wxPyEndAllowThreads(__tstate);
44342 if (PyErr_Occurred()) SWIG_fail;
44343 }
44344 resultobj = SWIG_From_int(static_cast< int >(result));
44345 {
44346 if (temp2)
44347 delete arg2;
44348 }
44349 return resultobj;
44350 fail:
44351 {
44352 if (temp2)
44353 delete arg2;
44354 }
44355 return NULL;
44356 }
44357
44358
44359 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44360 PyObject *resultobj = 0;
44361 wxMenu *arg1 = (wxMenu *) 0 ;
44362 int arg2 ;
44363 wxMenuItem *result = 0 ;
44364 void *argp1 = 0 ;
44365 int res1 = 0 ;
44366 int val2 ;
44367 int ecode2 = 0 ;
44368 PyObject * obj0 = 0 ;
44369 PyObject * obj1 = 0 ;
44370 char * kwnames[] = {
44371 (char *) "self",(char *) "id", NULL
44372 };
44373
44374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
44378 }
44379 arg1 = reinterpret_cast< wxMenu * >(argp1);
44380 ecode2 = SWIG_AsVal_int(obj1, &val2);
44381 if (!SWIG_IsOK(ecode2)) {
44382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
44383 }
44384 arg2 = static_cast< int >(val2);
44385 {
44386 PyThreadState* __tstate = wxPyBeginAllowThreads();
44387 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
44388 wxPyEndAllowThreads(__tstate);
44389 if (PyErr_Occurred()) SWIG_fail;
44390 }
44391 {
44392 resultobj = wxPyMake_wxObject(result, (bool)0);
44393 }
44394 return resultobj;
44395 fail:
44396 return NULL;
44397 }
44398
44399
44400 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44401 PyObject *resultobj = 0;
44402 wxMenu *arg1 = (wxMenu *) 0 ;
44403 size_t arg2 ;
44404 wxMenuItem *result = 0 ;
44405 void *argp1 = 0 ;
44406 int res1 = 0 ;
44407 size_t val2 ;
44408 int ecode2 = 0 ;
44409 PyObject * obj0 = 0 ;
44410 PyObject * obj1 = 0 ;
44411 char * kwnames[] = {
44412 (char *) "self",(char *) "position", NULL
44413 };
44414
44415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
44416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44417 if (!SWIG_IsOK(res1)) {
44418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
44419 }
44420 arg1 = reinterpret_cast< wxMenu * >(argp1);
44421 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44422 if (!SWIG_IsOK(ecode2)) {
44423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
44424 }
44425 arg2 = static_cast< size_t >(val2);
44426 {
44427 PyThreadState* __tstate = wxPyBeginAllowThreads();
44428 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
44429 wxPyEndAllowThreads(__tstate);
44430 if (PyErr_Occurred()) SWIG_fail;
44431 }
44432 {
44433 resultobj = wxPyMake_wxObject(result, (bool)0);
44434 }
44435 return resultobj;
44436 fail:
44437 return NULL;
44438 }
44439
44440
44441 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44442 PyObject *resultobj = 0;
44443 wxMenu *arg1 = (wxMenu *) 0 ;
44444 int arg2 ;
44445 bool arg3 ;
44446 void *argp1 = 0 ;
44447 int res1 = 0 ;
44448 int val2 ;
44449 int ecode2 = 0 ;
44450 bool val3 ;
44451 int ecode3 = 0 ;
44452 PyObject * obj0 = 0 ;
44453 PyObject * obj1 = 0 ;
44454 PyObject * obj2 = 0 ;
44455 char * kwnames[] = {
44456 (char *) "self",(char *) "id",(char *) "enable", NULL
44457 };
44458
44459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44461 if (!SWIG_IsOK(res1)) {
44462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
44463 }
44464 arg1 = reinterpret_cast< wxMenu * >(argp1);
44465 ecode2 = SWIG_AsVal_int(obj1, &val2);
44466 if (!SWIG_IsOK(ecode2)) {
44467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
44468 }
44469 arg2 = static_cast< int >(val2);
44470 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44471 if (!SWIG_IsOK(ecode3)) {
44472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
44473 }
44474 arg3 = static_cast< bool >(val3);
44475 {
44476 PyThreadState* __tstate = wxPyBeginAllowThreads();
44477 (arg1)->Enable(arg2,arg3);
44478 wxPyEndAllowThreads(__tstate);
44479 if (PyErr_Occurred()) SWIG_fail;
44480 }
44481 resultobj = SWIG_Py_Void();
44482 return resultobj;
44483 fail:
44484 return NULL;
44485 }
44486
44487
44488 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44489 PyObject *resultobj = 0;
44490 wxMenu *arg1 = (wxMenu *) 0 ;
44491 int arg2 ;
44492 bool result;
44493 void *argp1 = 0 ;
44494 int res1 = 0 ;
44495 int val2 ;
44496 int ecode2 = 0 ;
44497 PyObject * obj0 = 0 ;
44498 PyObject * obj1 = 0 ;
44499 char * kwnames[] = {
44500 (char *) "self",(char *) "id", NULL
44501 };
44502
44503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
44504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44505 if (!SWIG_IsOK(res1)) {
44506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
44507 }
44508 arg1 = reinterpret_cast< wxMenu * >(argp1);
44509 ecode2 = SWIG_AsVal_int(obj1, &val2);
44510 if (!SWIG_IsOK(ecode2)) {
44511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
44512 }
44513 arg2 = static_cast< int >(val2);
44514 {
44515 PyThreadState* __tstate = wxPyBeginAllowThreads();
44516 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
44517 wxPyEndAllowThreads(__tstate);
44518 if (PyErr_Occurred()) SWIG_fail;
44519 }
44520 {
44521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44522 }
44523 return resultobj;
44524 fail:
44525 return NULL;
44526 }
44527
44528
44529 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44530 PyObject *resultobj = 0;
44531 wxMenu *arg1 = (wxMenu *) 0 ;
44532 int arg2 ;
44533 bool arg3 ;
44534 void *argp1 = 0 ;
44535 int res1 = 0 ;
44536 int val2 ;
44537 int ecode2 = 0 ;
44538 bool val3 ;
44539 int ecode3 = 0 ;
44540 PyObject * obj0 = 0 ;
44541 PyObject * obj1 = 0 ;
44542 PyObject * obj2 = 0 ;
44543 char * kwnames[] = {
44544 (char *) "self",(char *) "id",(char *) "check", NULL
44545 };
44546
44547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44549 if (!SWIG_IsOK(res1)) {
44550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
44551 }
44552 arg1 = reinterpret_cast< wxMenu * >(argp1);
44553 ecode2 = SWIG_AsVal_int(obj1, &val2);
44554 if (!SWIG_IsOK(ecode2)) {
44555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
44556 }
44557 arg2 = static_cast< int >(val2);
44558 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44559 if (!SWIG_IsOK(ecode3)) {
44560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
44561 }
44562 arg3 = static_cast< bool >(val3);
44563 {
44564 PyThreadState* __tstate = wxPyBeginAllowThreads();
44565 (arg1)->Check(arg2,arg3);
44566 wxPyEndAllowThreads(__tstate);
44567 if (PyErr_Occurred()) SWIG_fail;
44568 }
44569 resultobj = SWIG_Py_Void();
44570 return resultobj;
44571 fail:
44572 return NULL;
44573 }
44574
44575
44576 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44577 PyObject *resultobj = 0;
44578 wxMenu *arg1 = (wxMenu *) 0 ;
44579 int arg2 ;
44580 bool result;
44581 void *argp1 = 0 ;
44582 int res1 = 0 ;
44583 int val2 ;
44584 int ecode2 = 0 ;
44585 PyObject * obj0 = 0 ;
44586 PyObject * obj1 = 0 ;
44587 char * kwnames[] = {
44588 (char *) "self",(char *) "id", NULL
44589 };
44590
44591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44593 if (!SWIG_IsOK(res1)) {
44594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44595 }
44596 arg1 = reinterpret_cast< wxMenu * >(argp1);
44597 ecode2 = SWIG_AsVal_int(obj1, &val2);
44598 if (!SWIG_IsOK(ecode2)) {
44599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44600 }
44601 arg2 = static_cast< int >(val2);
44602 {
44603 PyThreadState* __tstate = wxPyBeginAllowThreads();
44604 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44605 wxPyEndAllowThreads(__tstate);
44606 if (PyErr_Occurred()) SWIG_fail;
44607 }
44608 {
44609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44610 }
44611 return resultobj;
44612 fail:
44613 return NULL;
44614 }
44615
44616
44617 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44618 PyObject *resultobj = 0;
44619 wxMenu *arg1 = (wxMenu *) 0 ;
44620 int arg2 ;
44621 wxString *arg3 = 0 ;
44622 void *argp1 = 0 ;
44623 int res1 = 0 ;
44624 int val2 ;
44625 int ecode2 = 0 ;
44626 bool temp3 = false ;
44627 PyObject * obj0 = 0 ;
44628 PyObject * obj1 = 0 ;
44629 PyObject * obj2 = 0 ;
44630 char * kwnames[] = {
44631 (char *) "self",(char *) "id",(char *) "label", NULL
44632 };
44633
44634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44636 if (!SWIG_IsOK(res1)) {
44637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44638 }
44639 arg1 = reinterpret_cast< wxMenu * >(argp1);
44640 ecode2 = SWIG_AsVal_int(obj1, &val2);
44641 if (!SWIG_IsOK(ecode2)) {
44642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44643 }
44644 arg2 = static_cast< int >(val2);
44645 {
44646 arg3 = wxString_in_helper(obj2);
44647 if (arg3 == NULL) SWIG_fail;
44648 temp3 = true;
44649 }
44650 {
44651 PyThreadState* __tstate = wxPyBeginAllowThreads();
44652 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44653 wxPyEndAllowThreads(__tstate);
44654 if (PyErr_Occurred()) SWIG_fail;
44655 }
44656 resultobj = SWIG_Py_Void();
44657 {
44658 if (temp3)
44659 delete arg3;
44660 }
44661 return resultobj;
44662 fail:
44663 {
44664 if (temp3)
44665 delete arg3;
44666 }
44667 return NULL;
44668 }
44669
44670
44671 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44672 PyObject *resultobj = 0;
44673 wxMenu *arg1 = (wxMenu *) 0 ;
44674 int arg2 ;
44675 wxString result;
44676 void *argp1 = 0 ;
44677 int res1 = 0 ;
44678 int val2 ;
44679 int ecode2 = 0 ;
44680 PyObject * obj0 = 0 ;
44681 PyObject * obj1 = 0 ;
44682 char * kwnames[] = {
44683 (char *) "self",(char *) "id", NULL
44684 };
44685
44686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44688 if (!SWIG_IsOK(res1)) {
44689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44690 }
44691 arg1 = reinterpret_cast< wxMenu * >(argp1);
44692 ecode2 = SWIG_AsVal_int(obj1, &val2);
44693 if (!SWIG_IsOK(ecode2)) {
44694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44695 }
44696 arg2 = static_cast< int >(val2);
44697 {
44698 PyThreadState* __tstate = wxPyBeginAllowThreads();
44699 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44700 wxPyEndAllowThreads(__tstate);
44701 if (PyErr_Occurred()) SWIG_fail;
44702 }
44703 {
44704 #if wxUSE_UNICODE
44705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44706 #else
44707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44708 #endif
44709 }
44710 return resultobj;
44711 fail:
44712 return NULL;
44713 }
44714
44715
44716 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44717 PyObject *resultobj = 0;
44718 wxMenu *arg1 = (wxMenu *) 0 ;
44719 int arg2 ;
44720 wxString *arg3 = 0 ;
44721 void *argp1 = 0 ;
44722 int res1 = 0 ;
44723 int val2 ;
44724 int ecode2 = 0 ;
44725 bool temp3 = false ;
44726 PyObject * obj0 = 0 ;
44727 PyObject * obj1 = 0 ;
44728 PyObject * obj2 = 0 ;
44729 char * kwnames[] = {
44730 (char *) "self",(char *) "id",(char *) "helpString", NULL
44731 };
44732
44733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44735 if (!SWIG_IsOK(res1)) {
44736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44737 }
44738 arg1 = reinterpret_cast< wxMenu * >(argp1);
44739 ecode2 = SWIG_AsVal_int(obj1, &val2);
44740 if (!SWIG_IsOK(ecode2)) {
44741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44742 }
44743 arg2 = static_cast< int >(val2);
44744 {
44745 arg3 = wxString_in_helper(obj2);
44746 if (arg3 == NULL) SWIG_fail;
44747 temp3 = true;
44748 }
44749 {
44750 PyThreadState* __tstate = wxPyBeginAllowThreads();
44751 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44752 wxPyEndAllowThreads(__tstate);
44753 if (PyErr_Occurred()) SWIG_fail;
44754 }
44755 resultobj = SWIG_Py_Void();
44756 {
44757 if (temp3)
44758 delete arg3;
44759 }
44760 return resultobj;
44761 fail:
44762 {
44763 if (temp3)
44764 delete arg3;
44765 }
44766 return NULL;
44767 }
44768
44769
44770 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44771 PyObject *resultobj = 0;
44772 wxMenu *arg1 = (wxMenu *) 0 ;
44773 int arg2 ;
44774 wxString result;
44775 void *argp1 = 0 ;
44776 int res1 = 0 ;
44777 int val2 ;
44778 int ecode2 = 0 ;
44779 PyObject * obj0 = 0 ;
44780 PyObject * obj1 = 0 ;
44781 char * kwnames[] = {
44782 (char *) "self",(char *) "id", NULL
44783 };
44784
44785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44787 if (!SWIG_IsOK(res1)) {
44788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44789 }
44790 arg1 = reinterpret_cast< wxMenu * >(argp1);
44791 ecode2 = SWIG_AsVal_int(obj1, &val2);
44792 if (!SWIG_IsOK(ecode2)) {
44793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44794 }
44795 arg2 = static_cast< int >(val2);
44796 {
44797 PyThreadState* __tstate = wxPyBeginAllowThreads();
44798 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44799 wxPyEndAllowThreads(__tstate);
44800 if (PyErr_Occurred()) SWIG_fail;
44801 }
44802 {
44803 #if wxUSE_UNICODE
44804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44805 #else
44806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44807 #endif
44808 }
44809 return resultobj;
44810 fail:
44811 return NULL;
44812 }
44813
44814
44815 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44816 PyObject *resultobj = 0;
44817 wxMenu *arg1 = (wxMenu *) 0 ;
44818 wxString *arg2 = 0 ;
44819 void *argp1 = 0 ;
44820 int res1 = 0 ;
44821 bool temp2 = false ;
44822 PyObject * obj0 = 0 ;
44823 PyObject * obj1 = 0 ;
44824 char * kwnames[] = {
44825 (char *) "self",(char *) "title", NULL
44826 };
44827
44828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44830 if (!SWIG_IsOK(res1)) {
44831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44832 }
44833 arg1 = reinterpret_cast< wxMenu * >(argp1);
44834 {
44835 arg2 = wxString_in_helper(obj1);
44836 if (arg2 == NULL) SWIG_fail;
44837 temp2 = true;
44838 }
44839 {
44840 PyThreadState* __tstate = wxPyBeginAllowThreads();
44841 (arg1)->SetTitle((wxString const &)*arg2);
44842 wxPyEndAllowThreads(__tstate);
44843 if (PyErr_Occurred()) SWIG_fail;
44844 }
44845 resultobj = SWIG_Py_Void();
44846 {
44847 if (temp2)
44848 delete arg2;
44849 }
44850 return resultobj;
44851 fail:
44852 {
44853 if (temp2)
44854 delete arg2;
44855 }
44856 return NULL;
44857 }
44858
44859
44860 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44861 PyObject *resultobj = 0;
44862 wxMenu *arg1 = (wxMenu *) 0 ;
44863 wxString result;
44864 void *argp1 = 0 ;
44865 int res1 = 0 ;
44866 PyObject *swig_obj[1] ;
44867
44868 if (!args) SWIG_fail;
44869 swig_obj[0] = args;
44870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44871 if (!SWIG_IsOK(res1)) {
44872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44873 }
44874 arg1 = reinterpret_cast< wxMenu * >(argp1);
44875 {
44876 PyThreadState* __tstate = wxPyBeginAllowThreads();
44877 result = ((wxMenu const *)arg1)->GetTitle();
44878 wxPyEndAllowThreads(__tstate);
44879 if (PyErr_Occurred()) SWIG_fail;
44880 }
44881 {
44882 #if wxUSE_UNICODE
44883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44884 #else
44885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44886 #endif
44887 }
44888 return resultobj;
44889 fail:
44890 return NULL;
44891 }
44892
44893
44894 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44895 PyObject *resultobj = 0;
44896 wxMenu *arg1 = (wxMenu *) 0 ;
44897 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44898 void *argp1 = 0 ;
44899 int res1 = 0 ;
44900 void *argp2 = 0 ;
44901 int res2 = 0 ;
44902 PyObject * obj0 = 0 ;
44903 PyObject * obj1 = 0 ;
44904 char * kwnames[] = {
44905 (char *) "self",(char *) "handler", NULL
44906 };
44907
44908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44910 if (!SWIG_IsOK(res1)) {
44911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44912 }
44913 arg1 = reinterpret_cast< wxMenu * >(argp1);
44914 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44915 if (!SWIG_IsOK(res2)) {
44916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44917 }
44918 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44919 {
44920 PyThreadState* __tstate = wxPyBeginAllowThreads();
44921 (arg1)->SetEventHandler(arg2);
44922 wxPyEndAllowThreads(__tstate);
44923 if (PyErr_Occurred()) SWIG_fail;
44924 }
44925 resultobj = SWIG_Py_Void();
44926 return resultobj;
44927 fail:
44928 return NULL;
44929 }
44930
44931
44932 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44933 PyObject *resultobj = 0;
44934 wxMenu *arg1 = (wxMenu *) 0 ;
44935 wxEvtHandler *result = 0 ;
44936 void *argp1 = 0 ;
44937 int res1 = 0 ;
44938 PyObject *swig_obj[1] ;
44939
44940 if (!args) SWIG_fail;
44941 swig_obj[0] = args;
44942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44943 if (!SWIG_IsOK(res1)) {
44944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44945 }
44946 arg1 = reinterpret_cast< wxMenu * >(argp1);
44947 {
44948 PyThreadState* __tstate = wxPyBeginAllowThreads();
44949 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44950 wxPyEndAllowThreads(__tstate);
44951 if (PyErr_Occurred()) SWIG_fail;
44952 }
44953 {
44954 resultobj = wxPyMake_wxObject(result, 0);
44955 }
44956 return resultobj;
44957 fail:
44958 return NULL;
44959 }
44960
44961
44962 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44963 PyObject *resultobj = 0;
44964 wxMenu *arg1 = (wxMenu *) 0 ;
44965 wxWindow *arg2 = (wxWindow *) 0 ;
44966 void *argp1 = 0 ;
44967 int res1 = 0 ;
44968 void *argp2 = 0 ;
44969 int res2 = 0 ;
44970 PyObject * obj0 = 0 ;
44971 PyObject * obj1 = 0 ;
44972 char * kwnames[] = {
44973 (char *) "self",(char *) "win", NULL
44974 };
44975
44976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44978 if (!SWIG_IsOK(res1)) {
44979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44980 }
44981 arg1 = reinterpret_cast< wxMenu * >(argp1);
44982 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44983 if (!SWIG_IsOK(res2)) {
44984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44985 }
44986 arg2 = reinterpret_cast< wxWindow * >(argp2);
44987 {
44988 PyThreadState* __tstate = wxPyBeginAllowThreads();
44989 (arg1)->SetInvokingWindow(arg2);
44990 wxPyEndAllowThreads(__tstate);
44991 if (PyErr_Occurred()) SWIG_fail;
44992 }
44993 resultobj = SWIG_Py_Void();
44994 return resultobj;
44995 fail:
44996 return NULL;
44997 }
44998
44999
45000 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45001 PyObject *resultobj = 0;
45002 wxMenu *arg1 = (wxMenu *) 0 ;
45003 wxWindow *result = 0 ;
45004 void *argp1 = 0 ;
45005 int res1 = 0 ;
45006 PyObject *swig_obj[1] ;
45007
45008 if (!args) SWIG_fail;
45009 swig_obj[0] = args;
45010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45011 if (!SWIG_IsOK(res1)) {
45012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
45013 }
45014 arg1 = reinterpret_cast< wxMenu * >(argp1);
45015 {
45016 PyThreadState* __tstate = wxPyBeginAllowThreads();
45017 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
45018 wxPyEndAllowThreads(__tstate);
45019 if (PyErr_Occurred()) SWIG_fail;
45020 }
45021 {
45022 resultobj = wxPyMake_wxObject(result, 0);
45023 }
45024 return resultobj;
45025 fail:
45026 return NULL;
45027 }
45028
45029
45030 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45031 PyObject *resultobj = 0;
45032 wxMenu *arg1 = (wxMenu *) 0 ;
45033 long result;
45034 void *argp1 = 0 ;
45035 int res1 = 0 ;
45036 PyObject *swig_obj[1] ;
45037
45038 if (!args) SWIG_fail;
45039 swig_obj[0] = args;
45040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45041 if (!SWIG_IsOK(res1)) {
45042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
45043 }
45044 arg1 = reinterpret_cast< wxMenu * >(argp1);
45045 {
45046 PyThreadState* __tstate = wxPyBeginAllowThreads();
45047 result = (long)((wxMenu const *)arg1)->GetStyle();
45048 wxPyEndAllowThreads(__tstate);
45049 if (PyErr_Occurred()) SWIG_fail;
45050 }
45051 resultobj = SWIG_From_long(static_cast< long >(result));
45052 return resultobj;
45053 fail:
45054 return NULL;
45055 }
45056
45057
45058 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45059 PyObject *resultobj = 0;
45060 wxMenu *arg1 = (wxMenu *) 0 ;
45061 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
45062 void *argp1 = 0 ;
45063 int res1 = 0 ;
45064 void *argp2 = 0 ;
45065 int res2 = 0 ;
45066 PyObject * obj0 = 0 ;
45067 PyObject * obj1 = 0 ;
45068 char * kwnames[] = {
45069 (char *) "self",(char *) "source", NULL
45070 };
45071
45072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
45073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45074 if (!SWIG_IsOK(res1)) {
45075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
45076 }
45077 arg1 = reinterpret_cast< wxMenu * >(argp1);
45078 if (obj1) {
45079 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
45080 if (!SWIG_IsOK(res2)) {
45081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
45082 }
45083 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
45084 }
45085 {
45086 PyThreadState* __tstate = wxPyBeginAllowThreads();
45087 (arg1)->UpdateUI(arg2);
45088 wxPyEndAllowThreads(__tstate);
45089 if (PyErr_Occurred()) SWIG_fail;
45090 }
45091 resultobj = SWIG_Py_Void();
45092 return resultobj;
45093 fail:
45094 return NULL;
45095 }
45096
45097
45098 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45099 PyObject *resultobj = 0;
45100 wxMenu *arg1 = (wxMenu *) 0 ;
45101 wxMenuBar *result = 0 ;
45102 void *argp1 = 0 ;
45103 int res1 = 0 ;
45104 PyObject *swig_obj[1] ;
45105
45106 if (!args) SWIG_fail;
45107 swig_obj[0] = args;
45108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45109 if (!SWIG_IsOK(res1)) {
45110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
45111 }
45112 arg1 = reinterpret_cast< wxMenu * >(argp1);
45113 {
45114 PyThreadState* __tstate = wxPyBeginAllowThreads();
45115 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
45116 wxPyEndAllowThreads(__tstate);
45117 if (PyErr_Occurred()) SWIG_fail;
45118 }
45119 {
45120 resultobj = wxPyMake_wxObject(result, (bool)0);
45121 }
45122 return resultobj;
45123 fail:
45124 return NULL;
45125 }
45126
45127
45128 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45129 PyObject *resultobj = 0;
45130 wxMenu *arg1 = (wxMenu *) 0 ;
45131 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
45132 void *argp1 = 0 ;
45133 int res1 = 0 ;
45134 void *argp2 = 0 ;
45135 int res2 = 0 ;
45136 PyObject * obj0 = 0 ;
45137 PyObject * obj1 = 0 ;
45138 char * kwnames[] = {
45139 (char *) "self",(char *) "menubar", NULL
45140 };
45141
45142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45144 if (!SWIG_IsOK(res1)) {
45145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
45146 }
45147 arg1 = reinterpret_cast< wxMenu * >(argp1);
45148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
45149 if (!SWIG_IsOK(res2)) {
45150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
45151 }
45152 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
45153 {
45154 PyThreadState* __tstate = wxPyBeginAllowThreads();
45155 (arg1)->Attach(arg2);
45156 wxPyEndAllowThreads(__tstate);
45157 if (PyErr_Occurred()) SWIG_fail;
45158 }
45159 resultobj = SWIG_Py_Void();
45160 return resultobj;
45161 fail:
45162 return NULL;
45163 }
45164
45165
45166 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45167 PyObject *resultobj = 0;
45168 wxMenu *arg1 = (wxMenu *) 0 ;
45169 void *argp1 = 0 ;
45170 int res1 = 0 ;
45171 PyObject *swig_obj[1] ;
45172
45173 if (!args) SWIG_fail;
45174 swig_obj[0] = args;
45175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45176 if (!SWIG_IsOK(res1)) {
45177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
45178 }
45179 arg1 = reinterpret_cast< wxMenu * >(argp1);
45180 {
45181 PyThreadState* __tstate = wxPyBeginAllowThreads();
45182 (arg1)->Detach();
45183 wxPyEndAllowThreads(__tstate);
45184 if (PyErr_Occurred()) SWIG_fail;
45185 }
45186 resultobj = SWIG_Py_Void();
45187 return resultobj;
45188 fail:
45189 return NULL;
45190 }
45191
45192
45193 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45194 PyObject *resultobj = 0;
45195 wxMenu *arg1 = (wxMenu *) 0 ;
45196 bool result;
45197 void *argp1 = 0 ;
45198 int res1 = 0 ;
45199 PyObject *swig_obj[1] ;
45200
45201 if (!args) SWIG_fail;
45202 swig_obj[0] = args;
45203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45204 if (!SWIG_IsOK(res1)) {
45205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
45206 }
45207 arg1 = reinterpret_cast< wxMenu * >(argp1);
45208 {
45209 PyThreadState* __tstate = wxPyBeginAllowThreads();
45210 result = (bool)((wxMenu const *)arg1)->IsAttached();
45211 wxPyEndAllowThreads(__tstate);
45212 if (PyErr_Occurred()) SWIG_fail;
45213 }
45214 {
45215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45216 }
45217 return resultobj;
45218 fail:
45219 return NULL;
45220 }
45221
45222
45223 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45224 PyObject *resultobj = 0;
45225 wxMenu *arg1 = (wxMenu *) 0 ;
45226 wxMenu *arg2 = (wxMenu *) 0 ;
45227 void *argp1 = 0 ;
45228 int res1 = 0 ;
45229 void *argp2 = 0 ;
45230 int res2 = 0 ;
45231 PyObject * obj0 = 0 ;
45232 PyObject * obj1 = 0 ;
45233 char * kwnames[] = {
45234 (char *) "self",(char *) "parent", NULL
45235 };
45236
45237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
45238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45239 if (!SWIG_IsOK(res1)) {
45240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
45241 }
45242 arg1 = reinterpret_cast< wxMenu * >(argp1);
45243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45244 if (!SWIG_IsOK(res2)) {
45245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
45246 }
45247 arg2 = reinterpret_cast< wxMenu * >(argp2);
45248 {
45249 PyThreadState* __tstate = wxPyBeginAllowThreads();
45250 (arg1)->SetParent(arg2);
45251 wxPyEndAllowThreads(__tstate);
45252 if (PyErr_Occurred()) SWIG_fail;
45253 }
45254 resultobj = SWIG_Py_Void();
45255 return resultobj;
45256 fail:
45257 return NULL;
45258 }
45259
45260
45261 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45262 PyObject *resultobj = 0;
45263 wxMenu *arg1 = (wxMenu *) 0 ;
45264 wxMenu *result = 0 ;
45265 void *argp1 = 0 ;
45266 int res1 = 0 ;
45267 PyObject *swig_obj[1] ;
45268
45269 if (!args) SWIG_fail;
45270 swig_obj[0] = args;
45271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45272 if (!SWIG_IsOK(res1)) {
45273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
45274 }
45275 arg1 = reinterpret_cast< wxMenu * >(argp1);
45276 {
45277 PyThreadState* __tstate = wxPyBeginAllowThreads();
45278 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
45279 wxPyEndAllowThreads(__tstate);
45280 if (PyErr_Occurred()) SWIG_fail;
45281 }
45282 {
45283 resultobj = wxPyMake_wxObject(result, 0);
45284 }
45285 return resultobj;
45286 fail:
45287 return NULL;
45288 }
45289
45290
45291 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45292 PyObject *obj;
45293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45294 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
45295 return SWIG_Py_Void();
45296 }
45297
45298 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45299 return SWIG_Python_InitShadowInstance(args);
45300 }
45301
45302 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45303 PyObject *resultobj = 0;
45304 long arg1 = (long) 0 ;
45305 wxMenuBar *result = 0 ;
45306 long val1 ;
45307 int ecode1 = 0 ;
45308 PyObject * obj0 = 0 ;
45309 char * kwnames[] = {
45310 (char *) "style", NULL
45311 };
45312
45313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
45314 if (obj0) {
45315 ecode1 = SWIG_AsVal_long(obj0, &val1);
45316 if (!SWIG_IsOK(ecode1)) {
45317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
45318 }
45319 arg1 = static_cast< long >(val1);
45320 }
45321 {
45322 if (!wxPyCheckForApp()) SWIG_fail;
45323 PyThreadState* __tstate = wxPyBeginAllowThreads();
45324 result = (wxMenuBar *)new wxMenuBar(arg1);
45325 wxPyEndAllowThreads(__tstate);
45326 if (PyErr_Occurred()) SWIG_fail;
45327 }
45328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
45329 return resultobj;
45330 fail:
45331 return NULL;
45332 }
45333
45334
45335 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45336 PyObject *resultobj = 0;
45337 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45338 wxMenu *arg2 = (wxMenu *) 0 ;
45339 wxString *arg3 = 0 ;
45340 bool result;
45341 void *argp1 = 0 ;
45342 int res1 = 0 ;
45343 void *argp2 = 0 ;
45344 int res2 = 0 ;
45345 bool temp3 = false ;
45346 PyObject * obj0 = 0 ;
45347 PyObject * obj1 = 0 ;
45348 PyObject * obj2 = 0 ;
45349 char * kwnames[] = {
45350 (char *) "self",(char *) "menu",(char *) "title", NULL
45351 };
45352
45353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45355 if (!SWIG_IsOK(res1)) {
45356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45357 }
45358 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45359 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45360 if (!SWIG_IsOK(res2)) {
45361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
45362 }
45363 arg2 = reinterpret_cast< wxMenu * >(argp2);
45364 {
45365 arg3 = wxString_in_helper(obj2);
45366 if (arg3 == NULL) SWIG_fail;
45367 temp3 = true;
45368 }
45369 {
45370 PyThreadState* __tstate = wxPyBeginAllowThreads();
45371 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
45372 wxPyEndAllowThreads(__tstate);
45373 if (PyErr_Occurred()) SWIG_fail;
45374 }
45375 {
45376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45377 }
45378 {
45379 if (temp3)
45380 delete arg3;
45381 }
45382 return resultobj;
45383 fail:
45384 {
45385 if (temp3)
45386 delete arg3;
45387 }
45388 return NULL;
45389 }
45390
45391
45392 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45393 PyObject *resultobj = 0;
45394 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45395 size_t arg2 ;
45396 wxMenu *arg3 = (wxMenu *) 0 ;
45397 wxString *arg4 = 0 ;
45398 bool result;
45399 void *argp1 = 0 ;
45400 int res1 = 0 ;
45401 size_t val2 ;
45402 int ecode2 = 0 ;
45403 void *argp3 = 0 ;
45404 int res3 = 0 ;
45405 bool temp4 = false ;
45406 PyObject * obj0 = 0 ;
45407 PyObject * obj1 = 0 ;
45408 PyObject * obj2 = 0 ;
45409 PyObject * obj3 = 0 ;
45410 char * kwnames[] = {
45411 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45412 };
45413
45414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45416 if (!SWIG_IsOK(res1)) {
45417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45418 }
45419 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45420 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45421 if (!SWIG_IsOK(ecode2)) {
45422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
45423 }
45424 arg2 = static_cast< size_t >(val2);
45425 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45426 if (!SWIG_IsOK(res3)) {
45427 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
45428 }
45429 arg3 = reinterpret_cast< wxMenu * >(argp3);
45430 {
45431 arg4 = wxString_in_helper(obj3);
45432 if (arg4 == NULL) SWIG_fail;
45433 temp4 = true;
45434 }
45435 {
45436 PyThreadState* __tstate = wxPyBeginAllowThreads();
45437 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
45438 wxPyEndAllowThreads(__tstate);
45439 if (PyErr_Occurred()) SWIG_fail;
45440 }
45441 {
45442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45443 }
45444 {
45445 if (temp4)
45446 delete arg4;
45447 }
45448 return resultobj;
45449 fail:
45450 {
45451 if (temp4)
45452 delete arg4;
45453 }
45454 return NULL;
45455 }
45456
45457
45458 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45459 PyObject *resultobj = 0;
45460 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45461 size_t result;
45462 void *argp1 = 0 ;
45463 int res1 = 0 ;
45464 PyObject *swig_obj[1] ;
45465
45466 if (!args) SWIG_fail;
45467 swig_obj[0] = args;
45468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45469 if (!SWIG_IsOK(res1)) {
45470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45471 }
45472 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45473 {
45474 PyThreadState* __tstate = wxPyBeginAllowThreads();
45475 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
45476 wxPyEndAllowThreads(__tstate);
45477 if (PyErr_Occurred()) SWIG_fail;
45478 }
45479 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
45480 return resultobj;
45481 fail:
45482 return NULL;
45483 }
45484
45485
45486 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45487 PyObject *resultobj = 0;
45488 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45489 size_t arg2 ;
45490 wxMenu *result = 0 ;
45491 void *argp1 = 0 ;
45492 int res1 = 0 ;
45493 size_t val2 ;
45494 int ecode2 = 0 ;
45495 PyObject * obj0 = 0 ;
45496 PyObject * obj1 = 0 ;
45497 char * kwnames[] = {
45498 (char *) "self",(char *) "pos", NULL
45499 };
45500
45501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45503 if (!SWIG_IsOK(res1)) {
45504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45505 }
45506 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45507 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45508 if (!SWIG_IsOK(ecode2)) {
45509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
45510 }
45511 arg2 = static_cast< size_t >(val2);
45512 {
45513 PyThreadState* __tstate = wxPyBeginAllowThreads();
45514 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
45515 wxPyEndAllowThreads(__tstate);
45516 if (PyErr_Occurred()) SWIG_fail;
45517 }
45518 {
45519 resultobj = wxPyMake_wxObject(result, 0);
45520 }
45521 return resultobj;
45522 fail:
45523 return NULL;
45524 }
45525
45526
45527 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45528 PyObject *resultobj = 0;
45529 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45530 size_t arg2 ;
45531 wxMenu *arg3 = (wxMenu *) 0 ;
45532 wxString *arg4 = 0 ;
45533 wxMenu *result = 0 ;
45534 void *argp1 = 0 ;
45535 int res1 = 0 ;
45536 size_t val2 ;
45537 int ecode2 = 0 ;
45538 void *argp3 = 0 ;
45539 int res3 = 0 ;
45540 bool temp4 = false ;
45541 PyObject * obj0 = 0 ;
45542 PyObject * obj1 = 0 ;
45543 PyObject * obj2 = 0 ;
45544 PyObject * obj3 = 0 ;
45545 char * kwnames[] = {
45546 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45547 };
45548
45549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45551 if (!SWIG_IsOK(res1)) {
45552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45553 }
45554 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45555 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45556 if (!SWIG_IsOK(ecode2)) {
45557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
45558 }
45559 arg2 = static_cast< size_t >(val2);
45560 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45561 if (!SWIG_IsOK(res3)) {
45562 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
45563 }
45564 arg3 = reinterpret_cast< wxMenu * >(argp3);
45565 {
45566 arg4 = wxString_in_helper(obj3);
45567 if (arg4 == NULL) SWIG_fail;
45568 temp4 = true;
45569 }
45570 {
45571 PyThreadState* __tstate = wxPyBeginAllowThreads();
45572 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45573 wxPyEndAllowThreads(__tstate);
45574 if (PyErr_Occurred()) SWIG_fail;
45575 }
45576 {
45577 resultobj = wxPyMake_wxObject(result, 0);
45578 }
45579 {
45580 if (temp4)
45581 delete arg4;
45582 }
45583 return resultobj;
45584 fail:
45585 {
45586 if (temp4)
45587 delete arg4;
45588 }
45589 return NULL;
45590 }
45591
45592
45593 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45594 PyObject *resultobj = 0;
45595 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45596 size_t arg2 ;
45597 wxMenu *result = 0 ;
45598 void *argp1 = 0 ;
45599 int res1 = 0 ;
45600 size_t val2 ;
45601 int ecode2 = 0 ;
45602 PyObject * obj0 = 0 ;
45603 PyObject * obj1 = 0 ;
45604 char * kwnames[] = {
45605 (char *) "self",(char *) "pos", NULL
45606 };
45607
45608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45610 if (!SWIG_IsOK(res1)) {
45611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45612 }
45613 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45614 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45615 if (!SWIG_IsOK(ecode2)) {
45616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45617 }
45618 arg2 = static_cast< size_t >(val2);
45619 {
45620 PyThreadState* __tstate = wxPyBeginAllowThreads();
45621 result = (wxMenu *)(arg1)->Remove(arg2);
45622 wxPyEndAllowThreads(__tstate);
45623 if (PyErr_Occurred()) SWIG_fail;
45624 }
45625 {
45626 resultobj = wxPyMake_wxObject(result, 0);
45627 }
45628 return resultobj;
45629 fail:
45630 return NULL;
45631 }
45632
45633
45634 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45635 PyObject *resultobj = 0;
45636 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45637 size_t arg2 ;
45638 bool arg3 ;
45639 void *argp1 = 0 ;
45640 int res1 = 0 ;
45641 size_t val2 ;
45642 int ecode2 = 0 ;
45643 bool val3 ;
45644 int ecode3 = 0 ;
45645 PyObject * obj0 = 0 ;
45646 PyObject * obj1 = 0 ;
45647 PyObject * obj2 = 0 ;
45648 char * kwnames[] = {
45649 (char *) "self",(char *) "pos",(char *) "enable", NULL
45650 };
45651
45652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45654 if (!SWIG_IsOK(res1)) {
45655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45656 }
45657 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45658 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45659 if (!SWIG_IsOK(ecode2)) {
45660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45661 }
45662 arg2 = static_cast< size_t >(val2);
45663 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45664 if (!SWIG_IsOK(ecode3)) {
45665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45666 }
45667 arg3 = static_cast< bool >(val3);
45668 {
45669 PyThreadState* __tstate = wxPyBeginAllowThreads();
45670 (arg1)->EnableTop(arg2,arg3);
45671 wxPyEndAllowThreads(__tstate);
45672 if (PyErr_Occurred()) SWIG_fail;
45673 }
45674 resultobj = SWIG_Py_Void();
45675 return resultobj;
45676 fail:
45677 return NULL;
45678 }
45679
45680
45681 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45682 PyObject *resultobj = 0;
45683 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45684 size_t arg2 ;
45685 bool result;
45686 void *argp1 = 0 ;
45687 int res1 = 0 ;
45688 size_t val2 ;
45689 int ecode2 = 0 ;
45690 PyObject * obj0 = 0 ;
45691 PyObject * obj1 = 0 ;
45692 char * kwnames[] = {
45693 (char *) "self",(char *) "pos", NULL
45694 };
45695
45696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45698 if (!SWIG_IsOK(res1)) {
45699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45700 }
45701 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45702 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45703 if (!SWIG_IsOK(ecode2)) {
45704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45705 }
45706 arg2 = static_cast< size_t >(val2);
45707 {
45708 PyThreadState* __tstate = wxPyBeginAllowThreads();
45709 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45710 wxPyEndAllowThreads(__tstate);
45711 if (PyErr_Occurred()) SWIG_fail;
45712 }
45713 {
45714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45715 }
45716 return resultobj;
45717 fail:
45718 return NULL;
45719 }
45720
45721
45722 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45723 PyObject *resultobj = 0;
45724 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45725 size_t arg2 ;
45726 wxString *arg3 = 0 ;
45727 void *argp1 = 0 ;
45728 int res1 = 0 ;
45729 size_t val2 ;
45730 int ecode2 = 0 ;
45731 bool temp3 = false ;
45732 PyObject * obj0 = 0 ;
45733 PyObject * obj1 = 0 ;
45734 PyObject * obj2 = 0 ;
45735 char * kwnames[] = {
45736 (char *) "self",(char *) "pos",(char *) "label", NULL
45737 };
45738
45739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45741 if (!SWIG_IsOK(res1)) {
45742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45743 }
45744 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45745 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45746 if (!SWIG_IsOK(ecode2)) {
45747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45748 }
45749 arg2 = static_cast< size_t >(val2);
45750 {
45751 arg3 = wxString_in_helper(obj2);
45752 if (arg3 == NULL) SWIG_fail;
45753 temp3 = true;
45754 }
45755 {
45756 PyThreadState* __tstate = wxPyBeginAllowThreads();
45757 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45758 wxPyEndAllowThreads(__tstate);
45759 if (PyErr_Occurred()) SWIG_fail;
45760 }
45761 resultobj = SWIG_Py_Void();
45762 {
45763 if (temp3)
45764 delete arg3;
45765 }
45766 return resultobj;
45767 fail:
45768 {
45769 if (temp3)
45770 delete arg3;
45771 }
45772 return NULL;
45773 }
45774
45775
45776 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45777 PyObject *resultobj = 0;
45778 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45779 size_t arg2 ;
45780 wxString result;
45781 void *argp1 = 0 ;
45782 int res1 = 0 ;
45783 size_t val2 ;
45784 int ecode2 = 0 ;
45785 PyObject * obj0 = 0 ;
45786 PyObject * obj1 = 0 ;
45787 char * kwnames[] = {
45788 (char *) "self",(char *) "pos", NULL
45789 };
45790
45791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45793 if (!SWIG_IsOK(res1)) {
45794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45795 }
45796 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45797 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45798 if (!SWIG_IsOK(ecode2)) {
45799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45800 }
45801 arg2 = static_cast< size_t >(val2);
45802 {
45803 PyThreadState* __tstate = wxPyBeginAllowThreads();
45804 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45805 wxPyEndAllowThreads(__tstate);
45806 if (PyErr_Occurred()) SWIG_fail;
45807 }
45808 {
45809 #if wxUSE_UNICODE
45810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45811 #else
45812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45813 #endif
45814 }
45815 return resultobj;
45816 fail:
45817 return NULL;
45818 }
45819
45820
45821 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45822 PyObject *resultobj = 0;
45823 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45824 wxString *arg2 = 0 ;
45825 wxString *arg3 = 0 ;
45826 int result;
45827 void *argp1 = 0 ;
45828 int res1 = 0 ;
45829 bool temp2 = false ;
45830 bool temp3 = false ;
45831 PyObject * obj0 = 0 ;
45832 PyObject * obj1 = 0 ;
45833 PyObject * obj2 = 0 ;
45834 char * kwnames[] = {
45835 (char *) "self",(char *) "menu",(char *) "item", NULL
45836 };
45837
45838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45840 if (!SWIG_IsOK(res1)) {
45841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45842 }
45843 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45844 {
45845 arg2 = wxString_in_helper(obj1);
45846 if (arg2 == NULL) SWIG_fail;
45847 temp2 = true;
45848 }
45849 {
45850 arg3 = wxString_in_helper(obj2);
45851 if (arg3 == NULL) SWIG_fail;
45852 temp3 = true;
45853 }
45854 {
45855 PyThreadState* __tstate = wxPyBeginAllowThreads();
45856 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45857 wxPyEndAllowThreads(__tstate);
45858 if (PyErr_Occurred()) SWIG_fail;
45859 }
45860 resultobj = SWIG_From_int(static_cast< int >(result));
45861 {
45862 if (temp2)
45863 delete arg2;
45864 }
45865 {
45866 if (temp3)
45867 delete arg3;
45868 }
45869 return resultobj;
45870 fail:
45871 {
45872 if (temp2)
45873 delete arg2;
45874 }
45875 {
45876 if (temp3)
45877 delete arg3;
45878 }
45879 return NULL;
45880 }
45881
45882
45883 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45884 PyObject *resultobj = 0;
45885 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45886 int arg2 ;
45887 wxMenuItem *result = 0 ;
45888 void *argp1 = 0 ;
45889 int res1 = 0 ;
45890 int val2 ;
45891 int ecode2 = 0 ;
45892 PyObject * obj0 = 0 ;
45893 PyObject * obj1 = 0 ;
45894 char * kwnames[] = {
45895 (char *) "self",(char *) "id", NULL
45896 };
45897
45898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45900 if (!SWIG_IsOK(res1)) {
45901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45902 }
45903 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45904 ecode2 = SWIG_AsVal_int(obj1, &val2);
45905 if (!SWIG_IsOK(ecode2)) {
45906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45907 }
45908 arg2 = static_cast< int >(val2);
45909 {
45910 PyThreadState* __tstate = wxPyBeginAllowThreads();
45911 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45912 wxPyEndAllowThreads(__tstate);
45913 if (PyErr_Occurred()) SWIG_fail;
45914 }
45915 {
45916 resultobj = wxPyMake_wxObject(result, (bool)0);
45917 }
45918 return resultobj;
45919 fail:
45920 return NULL;
45921 }
45922
45923
45924 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45925 PyObject *resultobj = 0;
45926 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45927 wxString *arg2 = 0 ;
45928 int result;
45929 void *argp1 = 0 ;
45930 int res1 = 0 ;
45931 bool temp2 = false ;
45932 PyObject * obj0 = 0 ;
45933 PyObject * obj1 = 0 ;
45934 char * kwnames[] = {
45935 (char *) "self",(char *) "title", NULL
45936 };
45937
45938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45940 if (!SWIG_IsOK(res1)) {
45941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45942 }
45943 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45944 {
45945 arg2 = wxString_in_helper(obj1);
45946 if (arg2 == NULL) SWIG_fail;
45947 temp2 = true;
45948 }
45949 {
45950 PyThreadState* __tstate = wxPyBeginAllowThreads();
45951 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45952 wxPyEndAllowThreads(__tstate);
45953 if (PyErr_Occurred()) SWIG_fail;
45954 }
45955 resultobj = SWIG_From_int(static_cast< int >(result));
45956 {
45957 if (temp2)
45958 delete arg2;
45959 }
45960 return resultobj;
45961 fail:
45962 {
45963 if (temp2)
45964 delete arg2;
45965 }
45966 return NULL;
45967 }
45968
45969
45970 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45971 PyObject *resultobj = 0;
45972 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45973 int arg2 ;
45974 bool arg3 ;
45975 void *argp1 = 0 ;
45976 int res1 = 0 ;
45977 int val2 ;
45978 int ecode2 = 0 ;
45979 bool val3 ;
45980 int ecode3 = 0 ;
45981 PyObject * obj0 = 0 ;
45982 PyObject * obj1 = 0 ;
45983 PyObject * obj2 = 0 ;
45984 char * kwnames[] = {
45985 (char *) "self",(char *) "id",(char *) "enable", NULL
45986 };
45987
45988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45990 if (!SWIG_IsOK(res1)) {
45991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45992 }
45993 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45994 ecode2 = SWIG_AsVal_int(obj1, &val2);
45995 if (!SWIG_IsOK(ecode2)) {
45996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45997 }
45998 arg2 = static_cast< int >(val2);
45999 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46000 if (!SWIG_IsOK(ecode3)) {
46001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
46002 }
46003 arg3 = static_cast< bool >(val3);
46004 {
46005 PyThreadState* __tstate = wxPyBeginAllowThreads();
46006 (arg1)->Enable(arg2,arg3);
46007 wxPyEndAllowThreads(__tstate);
46008 if (PyErr_Occurred()) SWIG_fail;
46009 }
46010 resultobj = SWIG_Py_Void();
46011 return resultobj;
46012 fail:
46013 return NULL;
46014 }
46015
46016
46017 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46018 PyObject *resultobj = 0;
46019 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46020 int arg2 ;
46021 bool arg3 ;
46022 void *argp1 = 0 ;
46023 int res1 = 0 ;
46024 int val2 ;
46025 int ecode2 = 0 ;
46026 bool val3 ;
46027 int ecode3 = 0 ;
46028 PyObject * obj0 = 0 ;
46029 PyObject * obj1 = 0 ;
46030 PyObject * obj2 = 0 ;
46031 char * kwnames[] = {
46032 (char *) "self",(char *) "id",(char *) "check", NULL
46033 };
46034
46035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46037 if (!SWIG_IsOK(res1)) {
46038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46039 }
46040 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46041 ecode2 = SWIG_AsVal_int(obj1, &val2);
46042 if (!SWIG_IsOK(ecode2)) {
46043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
46044 }
46045 arg2 = static_cast< int >(val2);
46046 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46047 if (!SWIG_IsOK(ecode3)) {
46048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
46049 }
46050 arg3 = static_cast< bool >(val3);
46051 {
46052 PyThreadState* __tstate = wxPyBeginAllowThreads();
46053 (arg1)->Check(arg2,arg3);
46054 wxPyEndAllowThreads(__tstate);
46055 if (PyErr_Occurred()) SWIG_fail;
46056 }
46057 resultobj = SWIG_Py_Void();
46058 return resultobj;
46059 fail:
46060 return NULL;
46061 }
46062
46063
46064 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46065 PyObject *resultobj = 0;
46066 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46067 int arg2 ;
46068 bool result;
46069 void *argp1 = 0 ;
46070 int res1 = 0 ;
46071 int val2 ;
46072 int ecode2 = 0 ;
46073 PyObject * obj0 = 0 ;
46074 PyObject * obj1 = 0 ;
46075 char * kwnames[] = {
46076 (char *) "self",(char *) "id", NULL
46077 };
46078
46079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
46080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46081 if (!SWIG_IsOK(res1)) {
46082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46083 }
46084 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46085 ecode2 = SWIG_AsVal_int(obj1, &val2);
46086 if (!SWIG_IsOK(ecode2)) {
46087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
46088 }
46089 arg2 = static_cast< int >(val2);
46090 {
46091 PyThreadState* __tstate = wxPyBeginAllowThreads();
46092 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
46093 wxPyEndAllowThreads(__tstate);
46094 if (PyErr_Occurred()) SWIG_fail;
46095 }
46096 {
46097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46098 }
46099 return resultobj;
46100 fail:
46101 return NULL;
46102 }
46103
46104
46105 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46106 PyObject *resultobj = 0;
46107 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46108 int arg2 ;
46109 bool result;
46110 void *argp1 = 0 ;
46111 int res1 = 0 ;
46112 int val2 ;
46113 int ecode2 = 0 ;
46114 PyObject * obj0 = 0 ;
46115 PyObject * obj1 = 0 ;
46116 char * kwnames[] = {
46117 (char *) "self",(char *) "id", NULL
46118 };
46119
46120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
46121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46122 if (!SWIG_IsOK(res1)) {
46123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46124 }
46125 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46126 ecode2 = SWIG_AsVal_int(obj1, &val2);
46127 if (!SWIG_IsOK(ecode2)) {
46128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
46129 }
46130 arg2 = static_cast< int >(val2);
46131 {
46132 PyThreadState* __tstate = wxPyBeginAllowThreads();
46133 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
46134 wxPyEndAllowThreads(__tstate);
46135 if (PyErr_Occurred()) SWIG_fail;
46136 }
46137 {
46138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46139 }
46140 return resultobj;
46141 fail:
46142 return NULL;
46143 }
46144
46145
46146 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46147 PyObject *resultobj = 0;
46148 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46149 int arg2 ;
46150 wxString *arg3 = 0 ;
46151 void *argp1 = 0 ;
46152 int res1 = 0 ;
46153 int val2 ;
46154 int ecode2 = 0 ;
46155 bool temp3 = false ;
46156 PyObject * obj0 = 0 ;
46157 PyObject * obj1 = 0 ;
46158 PyObject * obj2 = 0 ;
46159 char * kwnames[] = {
46160 (char *) "self",(char *) "id",(char *) "label", NULL
46161 };
46162
46163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46165 if (!SWIG_IsOK(res1)) {
46166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46167 }
46168 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46169 ecode2 = SWIG_AsVal_int(obj1, &val2);
46170 if (!SWIG_IsOK(ecode2)) {
46171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
46172 }
46173 arg2 = static_cast< int >(val2);
46174 {
46175 arg3 = wxString_in_helper(obj2);
46176 if (arg3 == NULL) SWIG_fail;
46177 temp3 = true;
46178 }
46179 {
46180 PyThreadState* __tstate = wxPyBeginAllowThreads();
46181 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
46182 wxPyEndAllowThreads(__tstate);
46183 if (PyErr_Occurred()) SWIG_fail;
46184 }
46185 resultobj = SWIG_Py_Void();
46186 {
46187 if (temp3)
46188 delete arg3;
46189 }
46190 return resultobj;
46191 fail:
46192 {
46193 if (temp3)
46194 delete arg3;
46195 }
46196 return NULL;
46197 }
46198
46199
46200 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46201 PyObject *resultobj = 0;
46202 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46203 int arg2 ;
46204 wxString result;
46205 void *argp1 = 0 ;
46206 int res1 = 0 ;
46207 int val2 ;
46208 int ecode2 = 0 ;
46209 PyObject * obj0 = 0 ;
46210 PyObject * obj1 = 0 ;
46211 char * kwnames[] = {
46212 (char *) "self",(char *) "id", NULL
46213 };
46214
46215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
46216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46217 if (!SWIG_IsOK(res1)) {
46218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46219 }
46220 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46221 ecode2 = SWIG_AsVal_int(obj1, &val2);
46222 if (!SWIG_IsOK(ecode2)) {
46223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
46224 }
46225 arg2 = static_cast< int >(val2);
46226 {
46227 PyThreadState* __tstate = wxPyBeginAllowThreads();
46228 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
46229 wxPyEndAllowThreads(__tstate);
46230 if (PyErr_Occurred()) SWIG_fail;
46231 }
46232 {
46233 #if wxUSE_UNICODE
46234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46235 #else
46236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46237 #endif
46238 }
46239 return resultobj;
46240 fail:
46241 return NULL;
46242 }
46243
46244
46245 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46246 PyObject *resultobj = 0;
46247 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46248 int arg2 ;
46249 wxString *arg3 = 0 ;
46250 void *argp1 = 0 ;
46251 int res1 = 0 ;
46252 int val2 ;
46253 int ecode2 = 0 ;
46254 bool temp3 = false ;
46255 PyObject * obj0 = 0 ;
46256 PyObject * obj1 = 0 ;
46257 PyObject * obj2 = 0 ;
46258 char * kwnames[] = {
46259 (char *) "self",(char *) "id",(char *) "helpString", NULL
46260 };
46261
46262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46264 if (!SWIG_IsOK(res1)) {
46265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46266 }
46267 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46268 ecode2 = SWIG_AsVal_int(obj1, &val2);
46269 if (!SWIG_IsOK(ecode2)) {
46270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
46271 }
46272 arg2 = static_cast< int >(val2);
46273 {
46274 arg3 = wxString_in_helper(obj2);
46275 if (arg3 == NULL) SWIG_fail;
46276 temp3 = true;
46277 }
46278 {
46279 PyThreadState* __tstate = wxPyBeginAllowThreads();
46280 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
46281 wxPyEndAllowThreads(__tstate);
46282 if (PyErr_Occurred()) SWIG_fail;
46283 }
46284 resultobj = SWIG_Py_Void();
46285 {
46286 if (temp3)
46287 delete arg3;
46288 }
46289 return resultobj;
46290 fail:
46291 {
46292 if (temp3)
46293 delete arg3;
46294 }
46295 return NULL;
46296 }
46297
46298
46299 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46300 PyObject *resultobj = 0;
46301 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46302 int arg2 ;
46303 wxString result;
46304 void *argp1 = 0 ;
46305 int res1 = 0 ;
46306 int val2 ;
46307 int ecode2 = 0 ;
46308 PyObject * obj0 = 0 ;
46309 PyObject * obj1 = 0 ;
46310 char * kwnames[] = {
46311 (char *) "self",(char *) "id", NULL
46312 };
46313
46314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
46315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46316 if (!SWIG_IsOK(res1)) {
46317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46318 }
46319 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46320 ecode2 = SWIG_AsVal_int(obj1, &val2);
46321 if (!SWIG_IsOK(ecode2)) {
46322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
46323 }
46324 arg2 = static_cast< int >(val2);
46325 {
46326 PyThreadState* __tstate = wxPyBeginAllowThreads();
46327 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
46328 wxPyEndAllowThreads(__tstate);
46329 if (PyErr_Occurred()) SWIG_fail;
46330 }
46331 {
46332 #if wxUSE_UNICODE
46333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46334 #else
46335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46336 #endif
46337 }
46338 return resultobj;
46339 fail:
46340 return NULL;
46341 }
46342
46343
46344 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46345 PyObject *resultobj = 0;
46346 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46347 wxFrame *result = 0 ;
46348 void *argp1 = 0 ;
46349 int res1 = 0 ;
46350 PyObject *swig_obj[1] ;
46351
46352 if (!args) SWIG_fail;
46353 swig_obj[0] = args;
46354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46355 if (!SWIG_IsOK(res1)) {
46356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46357 }
46358 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46359 {
46360 PyThreadState* __tstate = wxPyBeginAllowThreads();
46361 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
46362 wxPyEndAllowThreads(__tstate);
46363 if (PyErr_Occurred()) SWIG_fail;
46364 }
46365 {
46366 resultobj = wxPyMake_wxObject(result, (bool)0);
46367 }
46368 return resultobj;
46369 fail:
46370 return NULL;
46371 }
46372
46373
46374 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46375 PyObject *resultobj = 0;
46376 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46377 bool result;
46378 void *argp1 = 0 ;
46379 int res1 = 0 ;
46380 PyObject *swig_obj[1] ;
46381
46382 if (!args) SWIG_fail;
46383 swig_obj[0] = args;
46384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46385 if (!SWIG_IsOK(res1)) {
46386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46387 }
46388 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46389 {
46390 PyThreadState* __tstate = wxPyBeginAllowThreads();
46391 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
46392 wxPyEndAllowThreads(__tstate);
46393 if (PyErr_Occurred()) SWIG_fail;
46394 }
46395 {
46396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46397 }
46398 return resultobj;
46399 fail:
46400 return NULL;
46401 }
46402
46403
46404 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46405 PyObject *resultobj = 0;
46406 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46407 wxFrame *arg2 = (wxFrame *) 0 ;
46408 void *argp1 = 0 ;
46409 int res1 = 0 ;
46410 void *argp2 = 0 ;
46411 int res2 = 0 ;
46412 PyObject * obj0 = 0 ;
46413 PyObject * obj1 = 0 ;
46414 char * kwnames[] = {
46415 (char *) "self",(char *) "frame", NULL
46416 };
46417
46418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
46419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46420 if (!SWIG_IsOK(res1)) {
46421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46422 }
46423 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
46425 if (!SWIG_IsOK(res2)) {
46426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
46427 }
46428 arg2 = reinterpret_cast< wxFrame * >(argp2);
46429 {
46430 PyThreadState* __tstate = wxPyBeginAllowThreads();
46431 (arg1)->Attach(arg2);
46432 wxPyEndAllowThreads(__tstate);
46433 if (PyErr_Occurred()) SWIG_fail;
46434 }
46435 resultobj = SWIG_Py_Void();
46436 return resultobj;
46437 fail:
46438 return NULL;
46439 }
46440
46441
46442 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46443 PyObject *resultobj = 0;
46444 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46445 void *argp1 = 0 ;
46446 int res1 = 0 ;
46447 PyObject *swig_obj[1] ;
46448
46449 if (!args) SWIG_fail;
46450 swig_obj[0] = args;
46451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46452 if (!SWIG_IsOK(res1)) {
46453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46454 }
46455 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46456 {
46457 PyThreadState* __tstate = wxPyBeginAllowThreads();
46458 (arg1)->Detach();
46459 wxPyEndAllowThreads(__tstate);
46460 if (PyErr_Occurred()) SWIG_fail;
46461 }
46462 resultobj = SWIG_Py_Void();
46463 return resultobj;
46464 fail:
46465 return NULL;
46466 }
46467
46468
46469 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46470 PyObject *resultobj = 0;
46471 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46472 void *argp1 = 0 ;
46473 int res1 = 0 ;
46474 PyObject *swig_obj[1] ;
46475
46476 if (!args) SWIG_fail;
46477 swig_obj[0] = args;
46478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46479 if (!SWIG_IsOK(res1)) {
46480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46481 }
46482 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46483 {
46484 PyThreadState* __tstate = wxPyBeginAllowThreads();
46485 (arg1)->UpdateMenus();
46486 wxPyEndAllowThreads(__tstate);
46487 if (PyErr_Occurred()) SWIG_fail;
46488 }
46489 resultobj = SWIG_Py_Void();
46490 return resultobj;
46491 fail:
46492 return NULL;
46493 }
46494
46495
46496 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46497 PyObject *resultobj = 0;
46498 bool arg1 ;
46499 bool val1 ;
46500 int ecode1 = 0 ;
46501 PyObject * obj0 = 0 ;
46502 char * kwnames[] = {
46503 (char *) "enable", NULL
46504 };
46505
46506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
46507 ecode1 = SWIG_AsVal_bool(obj0, &val1);
46508 if (!SWIG_IsOK(ecode1)) {
46509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
46510 }
46511 arg1 = static_cast< bool >(val1);
46512 {
46513 PyThreadState* __tstate = wxPyBeginAllowThreads();
46514 wxMenuBar_SetAutoWindowMenu(arg1);
46515 wxPyEndAllowThreads(__tstate);
46516 if (PyErr_Occurred()) SWIG_fail;
46517 }
46518 resultobj = SWIG_Py_Void();
46519 return resultobj;
46520 fail:
46521 return NULL;
46522 }
46523
46524
46525 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46526 PyObject *resultobj = 0;
46527 bool result;
46528
46529 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
46530 {
46531 PyThreadState* __tstate = wxPyBeginAllowThreads();
46532 result = (bool)wxMenuBar_GetAutoWindowMenu();
46533 wxPyEndAllowThreads(__tstate);
46534 if (PyErr_Occurred()) SWIG_fail;
46535 }
46536 {
46537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46538 }
46539 return resultobj;
46540 fail:
46541 return NULL;
46542 }
46543
46544
46545 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46546 PyObject *obj;
46547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46548 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
46549 return SWIG_Py_Void();
46550 }
46551
46552 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46553 return SWIG_Python_InitShadowInstance(args);
46554 }
46555
46556 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46557 PyObject *resultobj = 0;
46558 wxMenu *arg1 = (wxMenu *) NULL ;
46559 int arg2 = (int) wxID_SEPARATOR ;
46560 wxString const &arg3_defvalue = wxPyEmptyString ;
46561 wxString *arg3 = (wxString *) &arg3_defvalue ;
46562 wxString const &arg4_defvalue = wxPyEmptyString ;
46563 wxString *arg4 = (wxString *) &arg4_defvalue ;
46564 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
46565 wxMenu *arg6 = (wxMenu *) NULL ;
46566 wxMenuItem *result = 0 ;
46567 void *argp1 = 0 ;
46568 int res1 = 0 ;
46569 int val2 ;
46570 int ecode2 = 0 ;
46571 bool temp3 = false ;
46572 bool temp4 = false ;
46573 int val5 ;
46574 int ecode5 = 0 ;
46575 void *argp6 = 0 ;
46576 int res6 = 0 ;
46577 PyObject * obj0 = 0 ;
46578 PyObject * obj1 = 0 ;
46579 PyObject * obj2 = 0 ;
46580 PyObject * obj3 = 0 ;
46581 PyObject * obj4 = 0 ;
46582 PyObject * obj5 = 0 ;
46583 char * kwnames[] = {
46584 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46585 };
46586
46587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46588 if (obj0) {
46589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46590 if (!SWIG_IsOK(res1)) {
46591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46592 }
46593 arg1 = reinterpret_cast< wxMenu * >(argp1);
46594 }
46595 if (obj1) {
46596 ecode2 = SWIG_AsVal_int(obj1, &val2);
46597 if (!SWIG_IsOK(ecode2)) {
46598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46599 }
46600 arg2 = static_cast< int >(val2);
46601 }
46602 if (obj2) {
46603 {
46604 arg3 = wxString_in_helper(obj2);
46605 if (arg3 == NULL) SWIG_fail;
46606 temp3 = true;
46607 }
46608 }
46609 if (obj3) {
46610 {
46611 arg4 = wxString_in_helper(obj3);
46612 if (arg4 == NULL) SWIG_fail;
46613 temp4 = true;
46614 }
46615 }
46616 if (obj4) {
46617 ecode5 = SWIG_AsVal_int(obj4, &val5);
46618 if (!SWIG_IsOK(ecode5)) {
46619 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46620 }
46621 arg5 = static_cast< wxItemKind >(val5);
46622 }
46623 if (obj5) {
46624 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46625 if (!SWIG_IsOK(res6)) {
46626 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46627 }
46628 arg6 = reinterpret_cast< wxMenu * >(argp6);
46629 }
46630 {
46631 PyThreadState* __tstate = wxPyBeginAllowThreads();
46632 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46633 wxPyEndAllowThreads(__tstate);
46634 if (PyErr_Occurred()) SWIG_fail;
46635 }
46636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46637 {
46638 if (temp3)
46639 delete arg3;
46640 }
46641 {
46642 if (temp4)
46643 delete arg4;
46644 }
46645 return resultobj;
46646 fail:
46647 {
46648 if (temp3)
46649 delete arg3;
46650 }
46651 {
46652 if (temp4)
46653 delete arg4;
46654 }
46655 return NULL;
46656 }
46657
46658
46659 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46660 PyObject *resultobj = 0;
46661 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46662 void *argp1 = 0 ;
46663 int res1 = 0 ;
46664 PyObject *swig_obj[1] ;
46665
46666 if (!args) SWIG_fail;
46667 swig_obj[0] = args;
46668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46669 if (!SWIG_IsOK(res1)) {
46670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46671 }
46672 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46673 {
46674 PyThreadState* __tstate = wxPyBeginAllowThreads();
46675 delete arg1;
46676
46677 wxPyEndAllowThreads(__tstate);
46678 if (PyErr_Occurred()) SWIG_fail;
46679 }
46680 resultobj = SWIG_Py_Void();
46681 return resultobj;
46682 fail:
46683 return NULL;
46684 }
46685
46686
46687 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46688 PyObject *resultobj = 0;
46689 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46690 wxMenu *result = 0 ;
46691 void *argp1 = 0 ;
46692 int res1 = 0 ;
46693 PyObject *swig_obj[1] ;
46694
46695 if (!args) SWIG_fail;
46696 swig_obj[0] = args;
46697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46698 if (!SWIG_IsOK(res1)) {
46699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46700 }
46701 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46702 {
46703 PyThreadState* __tstate = wxPyBeginAllowThreads();
46704 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46705 wxPyEndAllowThreads(__tstate);
46706 if (PyErr_Occurred()) SWIG_fail;
46707 }
46708 {
46709 resultobj = wxPyMake_wxObject(result, 0);
46710 }
46711 return resultobj;
46712 fail:
46713 return NULL;
46714 }
46715
46716
46717 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46718 PyObject *resultobj = 0;
46719 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46720 wxMenu *arg2 = (wxMenu *) 0 ;
46721 void *argp1 = 0 ;
46722 int res1 = 0 ;
46723 void *argp2 = 0 ;
46724 int res2 = 0 ;
46725 PyObject * obj0 = 0 ;
46726 PyObject * obj1 = 0 ;
46727 char * kwnames[] = {
46728 (char *) "self",(char *) "menu", NULL
46729 };
46730
46731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46733 if (!SWIG_IsOK(res1)) {
46734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46735 }
46736 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46738 if (!SWIG_IsOK(res2)) {
46739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46740 }
46741 arg2 = reinterpret_cast< wxMenu * >(argp2);
46742 {
46743 PyThreadState* __tstate = wxPyBeginAllowThreads();
46744 (arg1)->SetMenu(arg2);
46745 wxPyEndAllowThreads(__tstate);
46746 if (PyErr_Occurred()) SWIG_fail;
46747 }
46748 resultobj = SWIG_Py_Void();
46749 return resultobj;
46750 fail:
46751 return NULL;
46752 }
46753
46754
46755 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46756 PyObject *resultobj = 0;
46757 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46758 int arg2 ;
46759 void *argp1 = 0 ;
46760 int res1 = 0 ;
46761 int val2 ;
46762 int ecode2 = 0 ;
46763 PyObject * obj0 = 0 ;
46764 PyObject * obj1 = 0 ;
46765 char * kwnames[] = {
46766 (char *) "self",(char *) "id", NULL
46767 };
46768
46769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46771 if (!SWIG_IsOK(res1)) {
46772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46773 }
46774 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46775 ecode2 = SWIG_AsVal_int(obj1, &val2);
46776 if (!SWIG_IsOK(ecode2)) {
46777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46778 }
46779 arg2 = static_cast< int >(val2);
46780 {
46781 PyThreadState* __tstate = wxPyBeginAllowThreads();
46782 (arg1)->SetId(arg2);
46783 wxPyEndAllowThreads(__tstate);
46784 if (PyErr_Occurred()) SWIG_fail;
46785 }
46786 resultobj = SWIG_Py_Void();
46787 return resultobj;
46788 fail:
46789 return NULL;
46790 }
46791
46792
46793 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46794 PyObject *resultobj = 0;
46795 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46796 int result;
46797 void *argp1 = 0 ;
46798 int res1 = 0 ;
46799 PyObject *swig_obj[1] ;
46800
46801 if (!args) SWIG_fail;
46802 swig_obj[0] = args;
46803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46804 if (!SWIG_IsOK(res1)) {
46805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46806 }
46807 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46808 {
46809 PyThreadState* __tstate = wxPyBeginAllowThreads();
46810 result = (int)((wxMenuItem const *)arg1)->GetId();
46811 wxPyEndAllowThreads(__tstate);
46812 if (PyErr_Occurred()) SWIG_fail;
46813 }
46814 resultobj = SWIG_From_int(static_cast< int >(result));
46815 return resultobj;
46816 fail:
46817 return NULL;
46818 }
46819
46820
46821 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46822 PyObject *resultobj = 0;
46823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46824 bool result;
46825 void *argp1 = 0 ;
46826 int res1 = 0 ;
46827 PyObject *swig_obj[1] ;
46828
46829 if (!args) SWIG_fail;
46830 swig_obj[0] = args;
46831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46832 if (!SWIG_IsOK(res1)) {
46833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46834 }
46835 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46836 {
46837 PyThreadState* __tstate = wxPyBeginAllowThreads();
46838 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46839 wxPyEndAllowThreads(__tstate);
46840 if (PyErr_Occurred()) SWIG_fail;
46841 }
46842 {
46843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46844 }
46845 return resultobj;
46846 fail:
46847 return NULL;
46848 }
46849
46850
46851 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46852 PyObject *resultobj = 0;
46853 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46854 wxString *arg2 = 0 ;
46855 void *argp1 = 0 ;
46856 int res1 = 0 ;
46857 bool temp2 = false ;
46858 PyObject * obj0 = 0 ;
46859 PyObject * obj1 = 0 ;
46860 char * kwnames[] = {
46861 (char *) "self",(char *) "str", NULL
46862 };
46863
46864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46866 if (!SWIG_IsOK(res1)) {
46867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46868 }
46869 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46870 {
46871 arg2 = wxString_in_helper(obj1);
46872 if (arg2 == NULL) SWIG_fail;
46873 temp2 = true;
46874 }
46875 {
46876 PyThreadState* __tstate = wxPyBeginAllowThreads();
46877 (arg1)->SetText((wxString const &)*arg2);
46878 wxPyEndAllowThreads(__tstate);
46879 if (PyErr_Occurred()) SWIG_fail;
46880 }
46881 resultobj = SWIG_Py_Void();
46882 {
46883 if (temp2)
46884 delete arg2;
46885 }
46886 return resultobj;
46887 fail:
46888 {
46889 if (temp2)
46890 delete arg2;
46891 }
46892 return NULL;
46893 }
46894
46895
46896 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46897 PyObject *resultobj = 0;
46898 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46899 wxString result;
46900 void *argp1 = 0 ;
46901 int res1 = 0 ;
46902 PyObject *swig_obj[1] ;
46903
46904 if (!args) SWIG_fail;
46905 swig_obj[0] = args;
46906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46907 if (!SWIG_IsOK(res1)) {
46908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46909 }
46910 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46911 {
46912 PyThreadState* __tstate = wxPyBeginAllowThreads();
46913 result = ((wxMenuItem const *)arg1)->GetLabel();
46914 wxPyEndAllowThreads(__tstate);
46915 if (PyErr_Occurred()) SWIG_fail;
46916 }
46917 {
46918 #if wxUSE_UNICODE
46919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46920 #else
46921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46922 #endif
46923 }
46924 return resultobj;
46925 fail:
46926 return NULL;
46927 }
46928
46929
46930 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46931 PyObject *resultobj = 0;
46932 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46933 wxString *result = 0 ;
46934 void *argp1 = 0 ;
46935 int res1 = 0 ;
46936 PyObject *swig_obj[1] ;
46937
46938 if (!args) SWIG_fail;
46939 swig_obj[0] = args;
46940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46941 if (!SWIG_IsOK(res1)) {
46942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46943 }
46944 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46945 {
46946 PyThreadState* __tstate = wxPyBeginAllowThreads();
46947 {
46948 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46949 result = (wxString *) &_result_ref;
46950 }
46951 wxPyEndAllowThreads(__tstate);
46952 if (PyErr_Occurred()) SWIG_fail;
46953 }
46954 {
46955 #if wxUSE_UNICODE
46956 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46957 #else
46958 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46959 #endif
46960 }
46961 return resultobj;
46962 fail:
46963 return NULL;
46964 }
46965
46966
46967 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46968 PyObject *resultobj = 0;
46969 wxString *arg1 = 0 ;
46970 wxString result;
46971 bool temp1 = false ;
46972 PyObject * obj0 = 0 ;
46973 char * kwnames[] = {
46974 (char *) "text", NULL
46975 };
46976
46977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46978 {
46979 arg1 = wxString_in_helper(obj0);
46980 if (arg1 == NULL) SWIG_fail;
46981 temp1 = true;
46982 }
46983 {
46984 PyThreadState* __tstate = wxPyBeginAllowThreads();
46985 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46986 wxPyEndAllowThreads(__tstate);
46987 if (PyErr_Occurred()) SWIG_fail;
46988 }
46989 {
46990 #if wxUSE_UNICODE
46991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46992 #else
46993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46994 #endif
46995 }
46996 {
46997 if (temp1)
46998 delete arg1;
46999 }
47000 return resultobj;
47001 fail:
47002 {
47003 if (temp1)
47004 delete arg1;
47005 }
47006 return NULL;
47007 }
47008
47009
47010 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47011 PyObject *resultobj = 0;
47012 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47013 wxItemKind result;
47014 void *argp1 = 0 ;
47015 int res1 = 0 ;
47016 PyObject *swig_obj[1] ;
47017
47018 if (!args) SWIG_fail;
47019 swig_obj[0] = args;
47020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47021 if (!SWIG_IsOK(res1)) {
47022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47023 }
47024 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47025 {
47026 PyThreadState* __tstate = wxPyBeginAllowThreads();
47027 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
47028 wxPyEndAllowThreads(__tstate);
47029 if (PyErr_Occurred()) SWIG_fail;
47030 }
47031 resultobj = SWIG_From_int(static_cast< int >(result));
47032 return resultobj;
47033 fail:
47034 return NULL;
47035 }
47036
47037
47038 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47039 PyObject *resultobj = 0;
47040 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47041 wxItemKind arg2 ;
47042 void *argp1 = 0 ;
47043 int res1 = 0 ;
47044 int val2 ;
47045 int ecode2 = 0 ;
47046 PyObject * obj0 = 0 ;
47047 PyObject * obj1 = 0 ;
47048 char * kwnames[] = {
47049 (char *) "self",(char *) "kind", NULL
47050 };
47051
47052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
47053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47054 if (!SWIG_IsOK(res1)) {
47055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47056 }
47057 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47058 ecode2 = SWIG_AsVal_int(obj1, &val2);
47059 if (!SWIG_IsOK(ecode2)) {
47060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
47061 }
47062 arg2 = static_cast< wxItemKind >(val2);
47063 {
47064 PyThreadState* __tstate = wxPyBeginAllowThreads();
47065 (arg1)->SetKind(arg2);
47066 wxPyEndAllowThreads(__tstate);
47067 if (PyErr_Occurred()) SWIG_fail;
47068 }
47069 resultobj = SWIG_Py_Void();
47070 return resultobj;
47071 fail:
47072 return NULL;
47073 }
47074
47075
47076 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47077 PyObject *resultobj = 0;
47078 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47079 bool arg2 ;
47080 void *argp1 = 0 ;
47081 int res1 = 0 ;
47082 bool val2 ;
47083 int ecode2 = 0 ;
47084 PyObject * obj0 = 0 ;
47085 PyObject * obj1 = 0 ;
47086 char * kwnames[] = {
47087 (char *) "self",(char *) "checkable", NULL
47088 };
47089
47090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
47091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47092 if (!SWIG_IsOK(res1)) {
47093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47094 }
47095 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47096 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47097 if (!SWIG_IsOK(ecode2)) {
47098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
47099 }
47100 arg2 = static_cast< bool >(val2);
47101 {
47102 PyThreadState* __tstate = wxPyBeginAllowThreads();
47103 (arg1)->SetCheckable(arg2);
47104 wxPyEndAllowThreads(__tstate);
47105 if (PyErr_Occurred()) SWIG_fail;
47106 }
47107 resultobj = SWIG_Py_Void();
47108 return resultobj;
47109 fail:
47110 return NULL;
47111 }
47112
47113
47114 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47115 PyObject *resultobj = 0;
47116 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47117 bool result;
47118 void *argp1 = 0 ;
47119 int res1 = 0 ;
47120 PyObject *swig_obj[1] ;
47121
47122 if (!args) SWIG_fail;
47123 swig_obj[0] = args;
47124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47125 if (!SWIG_IsOK(res1)) {
47126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47127 }
47128 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47129 {
47130 PyThreadState* __tstate = wxPyBeginAllowThreads();
47131 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
47132 wxPyEndAllowThreads(__tstate);
47133 if (PyErr_Occurred()) SWIG_fail;
47134 }
47135 {
47136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47137 }
47138 return resultobj;
47139 fail:
47140 return NULL;
47141 }
47142
47143
47144 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47145 PyObject *resultobj = 0;
47146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47147 bool result;
47148 void *argp1 = 0 ;
47149 int res1 = 0 ;
47150 PyObject *swig_obj[1] ;
47151
47152 if (!args) SWIG_fail;
47153 swig_obj[0] = args;
47154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47155 if (!SWIG_IsOK(res1)) {
47156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47157 }
47158 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47159 {
47160 PyThreadState* __tstate = wxPyBeginAllowThreads();
47161 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
47162 wxPyEndAllowThreads(__tstate);
47163 if (PyErr_Occurred()) SWIG_fail;
47164 }
47165 {
47166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47167 }
47168 return resultobj;
47169 fail:
47170 return NULL;
47171 }
47172
47173
47174 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47175 PyObject *resultobj = 0;
47176 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47177 wxMenu *arg2 = (wxMenu *) 0 ;
47178 void *argp1 = 0 ;
47179 int res1 = 0 ;
47180 void *argp2 = 0 ;
47181 int res2 = 0 ;
47182 PyObject * obj0 = 0 ;
47183 PyObject * obj1 = 0 ;
47184 char * kwnames[] = {
47185 (char *) "self",(char *) "menu", NULL
47186 };
47187
47188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
47189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47190 if (!SWIG_IsOK(res1)) {
47191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47192 }
47193 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47194 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
47195 if (!SWIG_IsOK(res2)) {
47196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
47197 }
47198 arg2 = reinterpret_cast< wxMenu * >(argp2);
47199 {
47200 PyThreadState* __tstate = wxPyBeginAllowThreads();
47201 (arg1)->SetSubMenu(arg2);
47202 wxPyEndAllowThreads(__tstate);
47203 if (PyErr_Occurred()) SWIG_fail;
47204 }
47205 resultobj = SWIG_Py_Void();
47206 return resultobj;
47207 fail:
47208 return NULL;
47209 }
47210
47211
47212 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47213 PyObject *resultobj = 0;
47214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47215 wxMenu *result = 0 ;
47216 void *argp1 = 0 ;
47217 int res1 = 0 ;
47218 PyObject *swig_obj[1] ;
47219
47220 if (!args) SWIG_fail;
47221 swig_obj[0] = args;
47222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47223 if (!SWIG_IsOK(res1)) {
47224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47225 }
47226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47227 {
47228 PyThreadState* __tstate = wxPyBeginAllowThreads();
47229 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
47230 wxPyEndAllowThreads(__tstate);
47231 if (PyErr_Occurred()) SWIG_fail;
47232 }
47233 {
47234 resultobj = wxPyMake_wxObject(result, 0);
47235 }
47236 return resultobj;
47237 fail:
47238 return NULL;
47239 }
47240
47241
47242 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47243 PyObject *resultobj = 0;
47244 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47245 bool arg2 = (bool) true ;
47246 void *argp1 = 0 ;
47247 int res1 = 0 ;
47248 bool val2 ;
47249 int ecode2 = 0 ;
47250 PyObject * obj0 = 0 ;
47251 PyObject * obj1 = 0 ;
47252 char * kwnames[] = {
47253 (char *) "self",(char *) "enable", NULL
47254 };
47255
47256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
47257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47258 if (!SWIG_IsOK(res1)) {
47259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47260 }
47261 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47262 if (obj1) {
47263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47264 if (!SWIG_IsOK(ecode2)) {
47265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
47266 }
47267 arg2 = static_cast< bool >(val2);
47268 }
47269 {
47270 PyThreadState* __tstate = wxPyBeginAllowThreads();
47271 (arg1)->Enable(arg2);
47272 wxPyEndAllowThreads(__tstate);
47273 if (PyErr_Occurred()) SWIG_fail;
47274 }
47275 resultobj = SWIG_Py_Void();
47276 return resultobj;
47277 fail:
47278 return NULL;
47279 }
47280
47281
47282 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47283 PyObject *resultobj = 0;
47284 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47285 bool result;
47286 void *argp1 = 0 ;
47287 int res1 = 0 ;
47288 PyObject *swig_obj[1] ;
47289
47290 if (!args) SWIG_fail;
47291 swig_obj[0] = args;
47292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47293 if (!SWIG_IsOK(res1)) {
47294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47295 }
47296 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47297 {
47298 PyThreadState* __tstate = wxPyBeginAllowThreads();
47299 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
47300 wxPyEndAllowThreads(__tstate);
47301 if (PyErr_Occurred()) SWIG_fail;
47302 }
47303 {
47304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47305 }
47306 return resultobj;
47307 fail:
47308 return NULL;
47309 }
47310
47311
47312 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47313 PyObject *resultobj = 0;
47314 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47315 bool arg2 = (bool) true ;
47316 void *argp1 = 0 ;
47317 int res1 = 0 ;
47318 bool val2 ;
47319 int ecode2 = 0 ;
47320 PyObject * obj0 = 0 ;
47321 PyObject * obj1 = 0 ;
47322 char * kwnames[] = {
47323 (char *) "self",(char *) "check", NULL
47324 };
47325
47326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
47327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47328 if (!SWIG_IsOK(res1)) {
47329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47330 }
47331 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47332 if (obj1) {
47333 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47334 if (!SWIG_IsOK(ecode2)) {
47335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
47336 }
47337 arg2 = static_cast< bool >(val2);
47338 }
47339 {
47340 PyThreadState* __tstate = wxPyBeginAllowThreads();
47341 (arg1)->Check(arg2);
47342 wxPyEndAllowThreads(__tstate);
47343 if (PyErr_Occurred()) SWIG_fail;
47344 }
47345 resultobj = SWIG_Py_Void();
47346 return resultobj;
47347 fail:
47348 return NULL;
47349 }
47350
47351
47352 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47353 PyObject *resultobj = 0;
47354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47355 bool result;
47356 void *argp1 = 0 ;
47357 int res1 = 0 ;
47358 PyObject *swig_obj[1] ;
47359
47360 if (!args) SWIG_fail;
47361 swig_obj[0] = args;
47362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47363 if (!SWIG_IsOK(res1)) {
47364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47365 }
47366 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47367 {
47368 PyThreadState* __tstate = wxPyBeginAllowThreads();
47369 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
47370 wxPyEndAllowThreads(__tstate);
47371 if (PyErr_Occurred()) SWIG_fail;
47372 }
47373 {
47374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47375 }
47376 return resultobj;
47377 fail:
47378 return NULL;
47379 }
47380
47381
47382 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47383 PyObject *resultobj = 0;
47384 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47385 void *argp1 = 0 ;
47386 int res1 = 0 ;
47387 PyObject *swig_obj[1] ;
47388
47389 if (!args) SWIG_fail;
47390 swig_obj[0] = args;
47391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47392 if (!SWIG_IsOK(res1)) {
47393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47394 }
47395 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47396 {
47397 PyThreadState* __tstate = wxPyBeginAllowThreads();
47398 (arg1)->Toggle();
47399 wxPyEndAllowThreads(__tstate);
47400 if (PyErr_Occurred()) SWIG_fail;
47401 }
47402 resultobj = SWIG_Py_Void();
47403 return resultobj;
47404 fail:
47405 return NULL;
47406 }
47407
47408
47409 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47410 PyObject *resultobj = 0;
47411 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47412 wxString *arg2 = 0 ;
47413 void *argp1 = 0 ;
47414 int res1 = 0 ;
47415 bool temp2 = false ;
47416 PyObject * obj0 = 0 ;
47417 PyObject * obj1 = 0 ;
47418 char * kwnames[] = {
47419 (char *) "self",(char *) "str", NULL
47420 };
47421
47422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
47423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47424 if (!SWIG_IsOK(res1)) {
47425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47426 }
47427 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47428 {
47429 arg2 = wxString_in_helper(obj1);
47430 if (arg2 == NULL) SWIG_fail;
47431 temp2 = true;
47432 }
47433 {
47434 PyThreadState* __tstate = wxPyBeginAllowThreads();
47435 (arg1)->SetHelp((wxString const &)*arg2);
47436 wxPyEndAllowThreads(__tstate);
47437 if (PyErr_Occurred()) SWIG_fail;
47438 }
47439 resultobj = SWIG_Py_Void();
47440 {
47441 if (temp2)
47442 delete arg2;
47443 }
47444 return resultobj;
47445 fail:
47446 {
47447 if (temp2)
47448 delete arg2;
47449 }
47450 return NULL;
47451 }
47452
47453
47454 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47455 PyObject *resultobj = 0;
47456 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47457 wxString *result = 0 ;
47458 void *argp1 = 0 ;
47459 int res1 = 0 ;
47460 PyObject *swig_obj[1] ;
47461
47462 if (!args) SWIG_fail;
47463 swig_obj[0] = args;
47464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47465 if (!SWIG_IsOK(res1)) {
47466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47467 }
47468 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47469 {
47470 PyThreadState* __tstate = wxPyBeginAllowThreads();
47471 {
47472 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
47473 result = (wxString *) &_result_ref;
47474 }
47475 wxPyEndAllowThreads(__tstate);
47476 if (PyErr_Occurred()) SWIG_fail;
47477 }
47478 {
47479 #if wxUSE_UNICODE
47480 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
47481 #else
47482 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
47483 #endif
47484 }
47485 return resultobj;
47486 fail:
47487 return NULL;
47488 }
47489
47490
47491 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47492 PyObject *resultobj = 0;
47493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47494 wxAcceleratorEntry *result = 0 ;
47495 void *argp1 = 0 ;
47496 int res1 = 0 ;
47497 PyObject *swig_obj[1] ;
47498
47499 if (!args) SWIG_fail;
47500 swig_obj[0] = args;
47501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47502 if (!SWIG_IsOK(res1)) {
47503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47504 }
47505 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47506 {
47507 PyThreadState* __tstate = wxPyBeginAllowThreads();
47508 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
47509 wxPyEndAllowThreads(__tstate);
47510 if (PyErr_Occurred()) SWIG_fail;
47511 }
47512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47513 return resultobj;
47514 fail:
47515 return NULL;
47516 }
47517
47518
47519 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47520 PyObject *resultobj = 0;
47521 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47522 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
47523 void *argp1 = 0 ;
47524 int res1 = 0 ;
47525 void *argp2 = 0 ;
47526 int res2 = 0 ;
47527 PyObject * obj0 = 0 ;
47528 PyObject * obj1 = 0 ;
47529 char * kwnames[] = {
47530 (char *) "self",(char *) "accel", NULL
47531 };
47532
47533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
47534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47535 if (!SWIG_IsOK(res1)) {
47536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47537 }
47538 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47540 if (!SWIG_IsOK(res2)) {
47541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
47542 }
47543 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
47544 {
47545 PyThreadState* __tstate = wxPyBeginAllowThreads();
47546 (arg1)->SetAccel(arg2);
47547 wxPyEndAllowThreads(__tstate);
47548 if (PyErr_Occurred()) SWIG_fail;
47549 }
47550 resultobj = SWIG_Py_Void();
47551 return resultobj;
47552 fail:
47553 return NULL;
47554 }
47555
47556
47557 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47558 PyObject *resultobj = 0;
47559 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47560 wxBitmap *arg2 = 0 ;
47561 void *argp1 = 0 ;
47562 int res1 = 0 ;
47563 void *argp2 = 0 ;
47564 int res2 = 0 ;
47565 PyObject * obj0 = 0 ;
47566 PyObject * obj1 = 0 ;
47567 char * kwnames[] = {
47568 (char *) "self",(char *) "bitmap", NULL
47569 };
47570
47571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47573 if (!SWIG_IsOK(res1)) {
47574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47575 }
47576 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47577 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47578 if (!SWIG_IsOK(res2)) {
47579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47580 }
47581 if (!argp2) {
47582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47583 }
47584 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47585 {
47586 PyThreadState* __tstate = wxPyBeginAllowThreads();
47587 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47588 wxPyEndAllowThreads(__tstate);
47589 if (PyErr_Occurred()) SWIG_fail;
47590 }
47591 resultobj = SWIG_Py_Void();
47592 return resultobj;
47593 fail:
47594 return NULL;
47595 }
47596
47597
47598 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47599 PyObject *resultobj = 0;
47600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47601 wxBitmap *result = 0 ;
47602 void *argp1 = 0 ;
47603 int res1 = 0 ;
47604 PyObject *swig_obj[1] ;
47605
47606 if (!args) SWIG_fail;
47607 swig_obj[0] = args;
47608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47609 if (!SWIG_IsOK(res1)) {
47610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47611 }
47612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47613 {
47614 PyThreadState* __tstate = wxPyBeginAllowThreads();
47615 {
47616 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47617 result = (wxBitmap *) &_result_ref;
47618 }
47619 wxPyEndAllowThreads(__tstate);
47620 if (PyErr_Occurred()) SWIG_fail;
47621 }
47622 {
47623 wxBitmap* resultptr = new wxBitmap(*result);
47624 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47625 }
47626 return resultobj;
47627 fail:
47628 return NULL;
47629 }
47630
47631
47632 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47633 PyObject *resultobj = 0;
47634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47635 wxFont *arg2 = 0 ;
47636 void *argp1 = 0 ;
47637 int res1 = 0 ;
47638 void *argp2 = 0 ;
47639 int res2 = 0 ;
47640 PyObject * obj0 = 0 ;
47641 PyObject * obj1 = 0 ;
47642 char * kwnames[] = {
47643 (char *) "self",(char *) "font", NULL
47644 };
47645
47646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47648 if (!SWIG_IsOK(res1)) {
47649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47650 }
47651 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47653 if (!SWIG_IsOK(res2)) {
47654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47655 }
47656 if (!argp2) {
47657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47658 }
47659 arg2 = reinterpret_cast< wxFont * >(argp2);
47660 {
47661 PyThreadState* __tstate = wxPyBeginAllowThreads();
47662 (arg1)->SetFont((wxFont const &)*arg2);
47663 wxPyEndAllowThreads(__tstate);
47664 if (PyErr_Occurred()) SWIG_fail;
47665 }
47666 resultobj = SWIG_Py_Void();
47667 return resultobj;
47668 fail:
47669 return NULL;
47670 }
47671
47672
47673 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47674 PyObject *resultobj = 0;
47675 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47676 wxFont result;
47677 void *argp1 = 0 ;
47678 int res1 = 0 ;
47679 PyObject *swig_obj[1] ;
47680
47681 if (!args) SWIG_fail;
47682 swig_obj[0] = args;
47683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47684 if (!SWIG_IsOK(res1)) {
47685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47686 }
47687 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47688 {
47689 PyThreadState* __tstate = wxPyBeginAllowThreads();
47690 result = (arg1)->GetFont();
47691 wxPyEndAllowThreads(__tstate);
47692 if (PyErr_Occurred()) SWIG_fail;
47693 }
47694 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47695 return resultobj;
47696 fail:
47697 return NULL;
47698 }
47699
47700
47701 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47702 PyObject *resultobj = 0;
47703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47704 wxColour *arg2 = 0 ;
47705 void *argp1 = 0 ;
47706 int res1 = 0 ;
47707 wxColour temp2 ;
47708 PyObject * obj0 = 0 ;
47709 PyObject * obj1 = 0 ;
47710 char * kwnames[] = {
47711 (char *) "self",(char *) "colText", NULL
47712 };
47713
47714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47716 if (!SWIG_IsOK(res1)) {
47717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47718 }
47719 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47720 {
47721 arg2 = &temp2;
47722 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47723 }
47724 {
47725 PyThreadState* __tstate = wxPyBeginAllowThreads();
47726 (arg1)->SetTextColour((wxColour const &)*arg2);
47727 wxPyEndAllowThreads(__tstate);
47728 if (PyErr_Occurred()) SWIG_fail;
47729 }
47730 resultobj = SWIG_Py_Void();
47731 return resultobj;
47732 fail:
47733 return NULL;
47734 }
47735
47736
47737 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47738 PyObject *resultobj = 0;
47739 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47740 wxColour result;
47741 void *argp1 = 0 ;
47742 int res1 = 0 ;
47743 PyObject *swig_obj[1] ;
47744
47745 if (!args) SWIG_fail;
47746 swig_obj[0] = args;
47747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47748 if (!SWIG_IsOK(res1)) {
47749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47750 }
47751 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47752 {
47753 PyThreadState* __tstate = wxPyBeginAllowThreads();
47754 result = (arg1)->GetTextColour();
47755 wxPyEndAllowThreads(__tstate);
47756 if (PyErr_Occurred()) SWIG_fail;
47757 }
47758 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47759 return resultobj;
47760 fail:
47761 return NULL;
47762 }
47763
47764
47765 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47766 PyObject *resultobj = 0;
47767 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47768 wxColour *arg2 = 0 ;
47769 void *argp1 = 0 ;
47770 int res1 = 0 ;
47771 wxColour temp2 ;
47772 PyObject * obj0 = 0 ;
47773 PyObject * obj1 = 0 ;
47774 char * kwnames[] = {
47775 (char *) "self",(char *) "colBack", NULL
47776 };
47777
47778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47780 if (!SWIG_IsOK(res1)) {
47781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47782 }
47783 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47784 {
47785 arg2 = &temp2;
47786 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47787 }
47788 {
47789 PyThreadState* __tstate = wxPyBeginAllowThreads();
47790 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
47791 wxPyEndAllowThreads(__tstate);
47792 if (PyErr_Occurred()) SWIG_fail;
47793 }
47794 resultobj = SWIG_Py_Void();
47795 return resultobj;
47796 fail:
47797 return NULL;
47798 }
47799
47800
47801 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47802 PyObject *resultobj = 0;
47803 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47804 wxColour result;
47805 void *argp1 = 0 ;
47806 int res1 = 0 ;
47807 PyObject *swig_obj[1] ;
47808
47809 if (!args) SWIG_fail;
47810 swig_obj[0] = args;
47811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47812 if (!SWIG_IsOK(res1)) {
47813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47814 }
47815 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47816 {
47817 PyThreadState* __tstate = wxPyBeginAllowThreads();
47818 result = (arg1)->GetBackgroundColour();
47819 wxPyEndAllowThreads(__tstate);
47820 if (PyErr_Occurred()) SWIG_fail;
47821 }
47822 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47823 return resultobj;
47824 fail:
47825 return NULL;
47826 }
47827
47828
47829 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47830 PyObject *resultobj = 0;
47831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47832 wxBitmap *arg2 = 0 ;
47833 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47834 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47835 void *argp1 = 0 ;
47836 int res1 = 0 ;
47837 void *argp2 = 0 ;
47838 int res2 = 0 ;
47839 void *argp3 = 0 ;
47840 int res3 = 0 ;
47841 PyObject * obj0 = 0 ;
47842 PyObject * obj1 = 0 ;
47843 PyObject * obj2 = 0 ;
47844 char * kwnames[] = {
47845 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47846 };
47847
47848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47850 if (!SWIG_IsOK(res1)) {
47851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47852 }
47853 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47854 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47855 if (!SWIG_IsOK(res2)) {
47856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47857 }
47858 if (!argp2) {
47859 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47860 }
47861 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47862 if (obj2) {
47863 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47864 if (!SWIG_IsOK(res3)) {
47865 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47866 }
47867 if (!argp3) {
47868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47869 }
47870 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47871 }
47872 {
47873 PyThreadState* __tstate = wxPyBeginAllowThreads();
47874 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47875 wxPyEndAllowThreads(__tstate);
47876 if (PyErr_Occurred()) SWIG_fail;
47877 }
47878 resultobj = SWIG_Py_Void();
47879 return resultobj;
47880 fail:
47881 return NULL;
47882 }
47883
47884
47885 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47886 PyObject *resultobj = 0;
47887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47888 wxBitmap *arg2 = 0 ;
47889 void *argp1 = 0 ;
47890 int res1 = 0 ;
47891 void *argp2 = 0 ;
47892 int res2 = 0 ;
47893 PyObject * obj0 = 0 ;
47894 PyObject * obj1 = 0 ;
47895 char * kwnames[] = {
47896 (char *) "self",(char *) "bmpDisabled", NULL
47897 };
47898
47899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47901 if (!SWIG_IsOK(res1)) {
47902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47903 }
47904 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47905 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47906 if (!SWIG_IsOK(res2)) {
47907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47908 }
47909 if (!argp2) {
47910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47911 }
47912 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47913 {
47914 PyThreadState* __tstate = wxPyBeginAllowThreads();
47915 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47916 wxPyEndAllowThreads(__tstate);
47917 if (PyErr_Occurred()) SWIG_fail;
47918 }
47919 resultobj = SWIG_Py_Void();
47920 return resultobj;
47921 fail:
47922 return NULL;
47923 }
47924
47925
47926 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47927 PyObject *resultobj = 0;
47928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47929 wxBitmap *result = 0 ;
47930 void *argp1 = 0 ;
47931 int res1 = 0 ;
47932 PyObject *swig_obj[1] ;
47933
47934 if (!args) SWIG_fail;
47935 swig_obj[0] = args;
47936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47937 if (!SWIG_IsOK(res1)) {
47938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47939 }
47940 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47941 {
47942 PyThreadState* __tstate = wxPyBeginAllowThreads();
47943 {
47944 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47945 result = (wxBitmap *) &_result_ref;
47946 }
47947 wxPyEndAllowThreads(__tstate);
47948 if (PyErr_Occurred()) SWIG_fail;
47949 }
47950 {
47951 wxBitmap* resultptr = new wxBitmap(*result);
47952 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47953 }
47954 return resultobj;
47955 fail:
47956 return NULL;
47957 }
47958
47959
47960 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47961 PyObject *resultobj = 0;
47962 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47963 int arg2 ;
47964 void *argp1 = 0 ;
47965 int res1 = 0 ;
47966 int val2 ;
47967 int ecode2 = 0 ;
47968 PyObject * obj0 = 0 ;
47969 PyObject * obj1 = 0 ;
47970 char * kwnames[] = {
47971 (char *) "self",(char *) "nWidth", NULL
47972 };
47973
47974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47976 if (!SWIG_IsOK(res1)) {
47977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47978 }
47979 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47980 ecode2 = SWIG_AsVal_int(obj1, &val2);
47981 if (!SWIG_IsOK(ecode2)) {
47982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47983 }
47984 arg2 = static_cast< int >(val2);
47985 {
47986 PyThreadState* __tstate = wxPyBeginAllowThreads();
47987 (arg1)->SetMarginWidth(arg2);
47988 wxPyEndAllowThreads(__tstate);
47989 if (PyErr_Occurred()) SWIG_fail;
47990 }
47991 resultobj = SWIG_Py_Void();
47992 return resultobj;
47993 fail:
47994 return NULL;
47995 }
47996
47997
47998 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47999 PyObject *resultobj = 0;
48000 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48001 int result;
48002 void *argp1 = 0 ;
48003 int res1 = 0 ;
48004 PyObject *swig_obj[1] ;
48005
48006 if (!args) SWIG_fail;
48007 swig_obj[0] = args;
48008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48009 if (!SWIG_IsOK(res1)) {
48010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48011 }
48012 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48013 {
48014 PyThreadState* __tstate = wxPyBeginAllowThreads();
48015 result = (int)(arg1)->GetMarginWidth();
48016 wxPyEndAllowThreads(__tstate);
48017 if (PyErr_Occurred()) SWIG_fail;
48018 }
48019 resultobj = SWIG_From_int(static_cast< int >(result));
48020 return resultobj;
48021 fail:
48022 return NULL;
48023 }
48024
48025
48026 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48027 PyObject *resultobj = 0;
48028 int result;
48029
48030 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
48031 {
48032 PyThreadState* __tstate = wxPyBeginAllowThreads();
48033 result = (int)wxMenuItem::GetDefaultMarginWidth();
48034 wxPyEndAllowThreads(__tstate);
48035 if (PyErr_Occurred()) SWIG_fail;
48036 }
48037 resultobj = SWIG_From_int(static_cast< int >(result));
48038 return resultobj;
48039 fail:
48040 return NULL;
48041 }
48042
48043
48044 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48045 PyObject *resultobj = 0;
48046 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48047 bool result;
48048 void *argp1 = 0 ;
48049 int res1 = 0 ;
48050 PyObject *swig_obj[1] ;
48051
48052 if (!args) SWIG_fail;
48053 swig_obj[0] = args;
48054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48055 if (!SWIG_IsOK(res1)) {
48056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48057 }
48058 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48059 {
48060 PyThreadState* __tstate = wxPyBeginAllowThreads();
48061 result = (bool)(arg1)->IsOwnerDrawn();
48062 wxPyEndAllowThreads(__tstate);
48063 if (PyErr_Occurred()) SWIG_fail;
48064 }
48065 {
48066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48067 }
48068 return resultobj;
48069 fail:
48070 return NULL;
48071 }
48072
48073
48074 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48075 PyObject *resultobj = 0;
48076 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48077 bool arg2 = (bool) true ;
48078 void *argp1 = 0 ;
48079 int res1 = 0 ;
48080 bool val2 ;
48081 int ecode2 = 0 ;
48082 PyObject * obj0 = 0 ;
48083 PyObject * obj1 = 0 ;
48084 char * kwnames[] = {
48085 (char *) "self",(char *) "ownerDrawn", NULL
48086 };
48087
48088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
48089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48090 if (!SWIG_IsOK(res1)) {
48091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48092 }
48093 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48094 if (obj1) {
48095 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48096 if (!SWIG_IsOK(ecode2)) {
48097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
48098 }
48099 arg2 = static_cast< bool >(val2);
48100 }
48101 {
48102 PyThreadState* __tstate = wxPyBeginAllowThreads();
48103 (arg1)->SetOwnerDrawn(arg2);
48104 wxPyEndAllowThreads(__tstate);
48105 if (PyErr_Occurred()) SWIG_fail;
48106 }
48107 resultobj = SWIG_Py_Void();
48108 return resultobj;
48109 fail:
48110 return NULL;
48111 }
48112
48113
48114 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48115 PyObject *resultobj = 0;
48116 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48117 void *argp1 = 0 ;
48118 int res1 = 0 ;
48119 PyObject *swig_obj[1] ;
48120
48121 if (!args) SWIG_fail;
48122 swig_obj[0] = args;
48123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48124 if (!SWIG_IsOK(res1)) {
48125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48126 }
48127 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48128 {
48129 PyThreadState* __tstate = wxPyBeginAllowThreads();
48130 (arg1)->ResetOwnerDrawn();
48131 wxPyEndAllowThreads(__tstate);
48132 if (PyErr_Occurred()) SWIG_fail;
48133 }
48134 resultobj = SWIG_Py_Void();
48135 return resultobj;
48136 fail:
48137 return NULL;
48138 }
48139
48140
48141 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48142 PyObject *obj;
48143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48144 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
48145 return SWIG_Py_Void();
48146 }
48147
48148 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48149 return SWIG_Python_InitShadowInstance(args);
48150 }
48151
48152 SWIGINTERN int ControlNameStr_set(PyObject *) {
48153 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
48154 return 1;
48155 }
48156
48157
48158 SWIGINTERN PyObject *ControlNameStr_get(void) {
48159 PyObject *pyobj = 0;
48160
48161 {
48162 #if wxUSE_UNICODE
48163 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48164 #else
48165 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48166 #endif
48167 }
48168 return pyobj;
48169 }
48170
48171
48172 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48173 PyObject *resultobj = 0;
48174 wxWindow *arg1 = (wxWindow *) 0 ;
48175 int arg2 = (int) -1 ;
48176 wxPoint const &arg3_defvalue = wxDefaultPosition ;
48177 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
48178 wxSize const &arg4_defvalue = wxDefaultSize ;
48179 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
48180 long arg5 = (long) 0 ;
48181 wxValidator const &arg6_defvalue = wxDefaultValidator ;
48182 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
48183 wxString const &arg7_defvalue = wxPyControlNameStr ;
48184 wxString *arg7 = (wxString *) &arg7_defvalue ;
48185 wxControl *result = 0 ;
48186 void *argp1 = 0 ;
48187 int res1 = 0 ;
48188 int val2 ;
48189 int ecode2 = 0 ;
48190 wxPoint temp3 ;
48191 wxSize temp4 ;
48192 long val5 ;
48193 int ecode5 = 0 ;
48194 void *argp6 = 0 ;
48195 int res6 = 0 ;
48196 bool temp7 = false ;
48197 PyObject * obj0 = 0 ;
48198 PyObject * obj1 = 0 ;
48199 PyObject * obj2 = 0 ;
48200 PyObject * obj3 = 0 ;
48201 PyObject * obj4 = 0 ;
48202 PyObject * obj5 = 0 ;
48203 PyObject * obj6 = 0 ;
48204 char * kwnames[] = {
48205 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48206 };
48207
48208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
48209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48210 if (!SWIG_IsOK(res1)) {
48211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
48212 }
48213 arg1 = reinterpret_cast< wxWindow * >(argp1);
48214 if (obj1) {
48215 ecode2 = SWIG_AsVal_int(obj1, &val2);
48216 if (!SWIG_IsOK(ecode2)) {
48217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
48218 }
48219 arg2 = static_cast< int >(val2);
48220 }
48221 if (obj2) {
48222 {
48223 arg3 = &temp3;
48224 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
48225 }
48226 }
48227 if (obj3) {
48228 {
48229 arg4 = &temp4;
48230 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
48231 }
48232 }
48233 if (obj4) {
48234 ecode5 = SWIG_AsVal_long(obj4, &val5);
48235 if (!SWIG_IsOK(ecode5)) {
48236 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
48237 }
48238 arg5 = static_cast< long >(val5);
48239 }
48240 if (obj5) {
48241 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
48242 if (!SWIG_IsOK(res6)) {
48243 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48244 }
48245 if (!argp6) {
48246 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48247 }
48248 arg6 = reinterpret_cast< wxValidator * >(argp6);
48249 }
48250 if (obj6) {
48251 {
48252 arg7 = wxString_in_helper(obj6);
48253 if (arg7 == NULL) SWIG_fail;
48254 temp7 = true;
48255 }
48256 }
48257 {
48258 if (!wxPyCheckForApp()) SWIG_fail;
48259 PyThreadState* __tstate = wxPyBeginAllowThreads();
48260 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
48261 wxPyEndAllowThreads(__tstate);
48262 if (PyErr_Occurred()) SWIG_fail;
48263 }
48264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
48265 {
48266 if (temp7)
48267 delete arg7;
48268 }
48269 return resultobj;
48270 fail:
48271 {
48272 if (temp7)
48273 delete arg7;
48274 }
48275 return NULL;
48276 }
48277
48278
48279 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48280 PyObject *resultobj = 0;
48281 wxControl *result = 0 ;
48282
48283 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
48284 {
48285 if (!wxPyCheckForApp()) SWIG_fail;
48286 PyThreadState* __tstate = wxPyBeginAllowThreads();
48287 result = (wxControl *)new wxControl();
48288 wxPyEndAllowThreads(__tstate);
48289 if (PyErr_Occurred()) SWIG_fail;
48290 }
48291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
48292 return resultobj;
48293 fail:
48294 return NULL;
48295 }
48296
48297
48298 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48299 PyObject *resultobj = 0;
48300 wxControl *arg1 = (wxControl *) 0 ;
48301 wxWindow *arg2 = (wxWindow *) 0 ;
48302 int arg3 = (int) -1 ;
48303 wxPoint const &arg4_defvalue = wxDefaultPosition ;
48304 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
48305 wxSize const &arg5_defvalue = wxDefaultSize ;
48306 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
48307 long arg6 = (long) 0 ;
48308 wxValidator const &arg7_defvalue = wxDefaultValidator ;
48309 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
48310 wxString const &arg8_defvalue = wxPyControlNameStr ;
48311 wxString *arg8 = (wxString *) &arg8_defvalue ;
48312 bool result;
48313 void *argp1 = 0 ;
48314 int res1 = 0 ;
48315 void *argp2 = 0 ;
48316 int res2 = 0 ;
48317 int val3 ;
48318 int ecode3 = 0 ;
48319 wxPoint temp4 ;
48320 wxSize temp5 ;
48321 long val6 ;
48322 int ecode6 = 0 ;
48323 void *argp7 = 0 ;
48324 int res7 = 0 ;
48325 bool temp8 = false ;
48326 PyObject * obj0 = 0 ;
48327 PyObject * obj1 = 0 ;
48328 PyObject * obj2 = 0 ;
48329 PyObject * obj3 = 0 ;
48330 PyObject * obj4 = 0 ;
48331 PyObject * obj5 = 0 ;
48332 PyObject * obj6 = 0 ;
48333 PyObject * obj7 = 0 ;
48334 char * kwnames[] = {
48335 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48336 };
48337
48338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
48339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48340 if (!SWIG_IsOK(res1)) {
48341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
48342 }
48343 arg1 = reinterpret_cast< wxControl * >(argp1);
48344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48345 if (!SWIG_IsOK(res2)) {
48346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
48347 }
48348 arg2 = reinterpret_cast< wxWindow * >(argp2);
48349 if (obj2) {
48350 ecode3 = SWIG_AsVal_int(obj2, &val3);
48351 if (!SWIG_IsOK(ecode3)) {
48352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
48353 }
48354 arg3 = static_cast< int >(val3);
48355 }
48356 if (obj3) {
48357 {
48358 arg4 = &temp4;
48359 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
48360 }
48361 }
48362 if (obj4) {
48363 {
48364 arg5 = &temp5;
48365 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
48366 }
48367 }
48368 if (obj5) {
48369 ecode6 = SWIG_AsVal_long(obj5, &val6);
48370 if (!SWIG_IsOK(ecode6)) {
48371 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
48372 }
48373 arg6 = static_cast< long >(val6);
48374 }
48375 if (obj6) {
48376 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
48377 if (!SWIG_IsOK(res7)) {
48378 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48379 }
48380 if (!argp7) {
48381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48382 }
48383 arg7 = reinterpret_cast< wxValidator * >(argp7);
48384 }
48385 if (obj7) {
48386 {
48387 arg8 = wxString_in_helper(obj7);
48388 if (arg8 == NULL) SWIG_fail;
48389 temp8 = true;
48390 }
48391 }
48392 {
48393 PyThreadState* __tstate = wxPyBeginAllowThreads();
48394 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
48395 wxPyEndAllowThreads(__tstate);
48396 if (PyErr_Occurred()) SWIG_fail;
48397 }
48398 {
48399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48400 }
48401 {
48402 if (temp8)
48403 delete arg8;
48404 }
48405 return resultobj;
48406 fail:
48407 {
48408 if (temp8)
48409 delete arg8;
48410 }
48411 return NULL;
48412 }
48413
48414
48415 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48416 PyObject *resultobj = 0;
48417 wxControl *arg1 = (wxControl *) 0 ;
48418 int result;
48419 void *argp1 = 0 ;
48420 int res1 = 0 ;
48421 PyObject *swig_obj[1] ;
48422
48423 if (!args) SWIG_fail;
48424 swig_obj[0] = args;
48425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48426 if (!SWIG_IsOK(res1)) {
48427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
48428 }
48429 arg1 = reinterpret_cast< wxControl * >(argp1);
48430 {
48431 PyThreadState* __tstate = wxPyBeginAllowThreads();
48432 result = (int)((wxControl const *)arg1)->GetAlignment();
48433 wxPyEndAllowThreads(__tstate);
48434 if (PyErr_Occurred()) SWIG_fail;
48435 }
48436 resultobj = SWIG_From_int(static_cast< int >(result));
48437 return resultobj;
48438 fail:
48439 return NULL;
48440 }
48441
48442
48443 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48444 PyObject *resultobj = 0;
48445 wxControl *arg1 = (wxControl *) 0 ;
48446 wxString result;
48447 void *argp1 = 0 ;
48448 int res1 = 0 ;
48449 PyObject *swig_obj[1] ;
48450
48451 if (!args) SWIG_fail;
48452 swig_obj[0] = args;
48453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48454 if (!SWIG_IsOK(res1)) {
48455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
48456 }
48457 arg1 = reinterpret_cast< wxControl * >(argp1);
48458 {
48459 PyThreadState* __tstate = wxPyBeginAllowThreads();
48460 result = ((wxControl const *)arg1)->GetLabelText();
48461 wxPyEndAllowThreads(__tstate);
48462 if (PyErr_Occurred()) SWIG_fail;
48463 }
48464 {
48465 #if wxUSE_UNICODE
48466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48467 #else
48468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48469 #endif
48470 }
48471 return resultobj;
48472 fail:
48473 return NULL;
48474 }
48475
48476
48477 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48478 PyObject *resultobj = 0;
48479 wxControl *arg1 = (wxControl *) 0 ;
48480 wxCommandEvent *arg2 = 0 ;
48481 void *argp1 = 0 ;
48482 int res1 = 0 ;
48483 void *argp2 = 0 ;
48484 int res2 = 0 ;
48485 PyObject * obj0 = 0 ;
48486 PyObject * obj1 = 0 ;
48487 char * kwnames[] = {
48488 (char *) "self",(char *) "event", NULL
48489 };
48490
48491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
48492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48493 if (!SWIG_IsOK(res1)) {
48494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
48495 }
48496 arg1 = reinterpret_cast< wxControl * >(argp1);
48497 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
48498 if (!SWIG_IsOK(res2)) {
48499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48500 }
48501 if (!argp2) {
48502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48503 }
48504 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
48505 {
48506 PyThreadState* __tstate = wxPyBeginAllowThreads();
48507 (arg1)->Command(*arg2);
48508 wxPyEndAllowThreads(__tstate);
48509 if (PyErr_Occurred()) SWIG_fail;
48510 }
48511 resultobj = SWIG_Py_Void();
48512 return resultobj;
48513 fail:
48514 return NULL;
48515 }
48516
48517
48518 SWIGINTERN PyObject *_wrap_Control_RemoveMnemonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48519 PyObject *resultobj = 0;
48520 wxString *arg1 = 0 ;
48521 wxString result;
48522 bool temp1 = false ;
48523 PyObject * obj0 = 0 ;
48524 char * kwnames[] = {
48525 (char *) "str", NULL
48526 };
48527
48528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_RemoveMnemonics",kwnames,&obj0)) SWIG_fail;
48529 {
48530 arg1 = wxString_in_helper(obj0);
48531 if (arg1 == NULL) SWIG_fail;
48532 temp1 = true;
48533 }
48534 {
48535 PyThreadState* __tstate = wxPyBeginAllowThreads();
48536 result = wxControl::RemoveMnemonics((wxString const &)*arg1);
48537 wxPyEndAllowThreads(__tstate);
48538 if (PyErr_Occurred()) SWIG_fail;
48539 }
48540 {
48541 #if wxUSE_UNICODE
48542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48543 #else
48544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48545 #endif
48546 }
48547 {
48548 if (temp1)
48549 delete arg1;
48550 }
48551 return resultobj;
48552 fail:
48553 {
48554 if (temp1)
48555 delete arg1;
48556 }
48557 return NULL;
48558 }
48559
48560
48561 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48562 PyObject *resultobj = 0;
48563 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
48564 SwigValueWrapper<wxVisualAttributes > result;
48565 int val1 ;
48566 int ecode1 = 0 ;
48567 PyObject * obj0 = 0 ;
48568 char * kwnames[] = {
48569 (char *) "variant", NULL
48570 };
48571
48572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
48573 if (obj0) {
48574 ecode1 = SWIG_AsVal_int(obj0, &val1);
48575 if (!SWIG_IsOK(ecode1)) {
48576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
48577 }
48578 arg1 = static_cast< wxWindowVariant >(val1);
48579 }
48580 {
48581 if (!wxPyCheckForApp()) SWIG_fail;
48582 PyThreadState* __tstate = wxPyBeginAllowThreads();
48583 result = wxControl::GetClassDefaultAttributes(arg1);
48584 wxPyEndAllowThreads(__tstate);
48585 if (PyErr_Occurred()) SWIG_fail;
48586 }
48587 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48588 return resultobj;
48589 fail:
48590 return NULL;
48591 }
48592
48593
48594 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48595 PyObject *obj;
48596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48597 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48598 return SWIG_Py_Void();
48599 }
48600
48601 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48602 return SWIG_Python_InitShadowInstance(args);
48603 }
48604
48605 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48606 PyObject *resultobj = 0;
48607 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48608 wxString *arg2 = 0 ;
48609 PyObject *arg3 = (PyObject *) NULL ;
48610 int result;
48611 void *argp1 = 0 ;
48612 int res1 = 0 ;
48613 bool temp2 = false ;
48614 PyObject * obj0 = 0 ;
48615 PyObject * obj1 = 0 ;
48616 PyObject * obj2 = 0 ;
48617 char * kwnames[] = {
48618 (char *) "self",(char *) "item",(char *) "clientData", NULL
48619 };
48620
48621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48623 if (!SWIG_IsOK(res1)) {
48624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48625 }
48626 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48627 {
48628 arg2 = wxString_in_helper(obj1);
48629 if (arg2 == NULL) SWIG_fail;
48630 temp2 = true;
48631 }
48632 if (obj2) {
48633 arg3 = obj2;
48634 }
48635 {
48636 PyThreadState* __tstate = wxPyBeginAllowThreads();
48637 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48638 wxPyEndAllowThreads(__tstate);
48639 if (PyErr_Occurred()) SWIG_fail;
48640 }
48641 resultobj = SWIG_From_int(static_cast< int >(result));
48642 {
48643 if (temp2)
48644 delete arg2;
48645 }
48646 return resultobj;
48647 fail:
48648 {
48649 if (temp2)
48650 delete arg2;
48651 }
48652 return NULL;
48653 }
48654
48655
48656 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48657 PyObject *resultobj = 0;
48658 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48659 wxArrayString *arg2 = 0 ;
48660 void *argp1 = 0 ;
48661 int res1 = 0 ;
48662 bool temp2 = false ;
48663 PyObject * obj0 = 0 ;
48664 PyObject * obj1 = 0 ;
48665 char * kwnames[] = {
48666 (char *) "self",(char *) "strings", NULL
48667 };
48668
48669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48671 if (!SWIG_IsOK(res1)) {
48672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48673 }
48674 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48675 {
48676 if (! PySequence_Check(obj1)) {
48677 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48678 SWIG_fail;
48679 }
48680 arg2 = new wxArrayString;
48681 temp2 = true;
48682 int i, len=PySequence_Length(obj1);
48683 for (i=0; i<len; i++) {
48684 PyObject* item = PySequence_GetItem(obj1, i);
48685 wxString* s = wxString_in_helper(item);
48686 if (PyErr_Occurred()) SWIG_fail;
48687 arg2->Add(*s);
48688 delete s;
48689 Py_DECREF(item);
48690 }
48691 }
48692 {
48693 PyThreadState* __tstate = wxPyBeginAllowThreads();
48694 (arg1)->Append((wxArrayString const &)*arg2);
48695 wxPyEndAllowThreads(__tstate);
48696 if (PyErr_Occurred()) SWIG_fail;
48697 }
48698 resultobj = SWIG_Py_Void();
48699 {
48700 if (temp2) delete arg2;
48701 }
48702 return resultobj;
48703 fail:
48704 {
48705 if (temp2) delete arg2;
48706 }
48707 return NULL;
48708 }
48709
48710
48711 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48712 PyObject *resultobj = 0;
48713 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48714 wxString *arg2 = 0 ;
48715 int arg3 ;
48716 PyObject *arg4 = (PyObject *) NULL ;
48717 int result;
48718 void *argp1 = 0 ;
48719 int res1 = 0 ;
48720 bool temp2 = false ;
48721 int val3 ;
48722 int ecode3 = 0 ;
48723 PyObject * obj0 = 0 ;
48724 PyObject * obj1 = 0 ;
48725 PyObject * obj2 = 0 ;
48726 PyObject * obj3 = 0 ;
48727 char * kwnames[] = {
48728 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48729 };
48730
48731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48733 if (!SWIG_IsOK(res1)) {
48734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48735 }
48736 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48737 {
48738 arg2 = wxString_in_helper(obj1);
48739 if (arg2 == NULL) SWIG_fail;
48740 temp2 = true;
48741 }
48742 ecode3 = SWIG_AsVal_int(obj2, &val3);
48743 if (!SWIG_IsOK(ecode3)) {
48744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48745 }
48746 arg3 = static_cast< int >(val3);
48747 if (obj3) {
48748 arg4 = obj3;
48749 }
48750 {
48751 PyThreadState* __tstate = wxPyBeginAllowThreads();
48752 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48753 wxPyEndAllowThreads(__tstate);
48754 if (PyErr_Occurred()) SWIG_fail;
48755 }
48756 resultobj = SWIG_From_int(static_cast< int >(result));
48757 {
48758 if (temp2)
48759 delete arg2;
48760 }
48761 return resultobj;
48762 fail:
48763 {
48764 if (temp2)
48765 delete arg2;
48766 }
48767 return NULL;
48768 }
48769
48770
48771 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48772 PyObject *resultobj = 0;
48773 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48774 void *argp1 = 0 ;
48775 int res1 = 0 ;
48776 PyObject *swig_obj[1] ;
48777
48778 if (!args) SWIG_fail;
48779 swig_obj[0] = args;
48780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48781 if (!SWIG_IsOK(res1)) {
48782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48783 }
48784 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48785 {
48786 PyThreadState* __tstate = wxPyBeginAllowThreads();
48787 (arg1)->Clear();
48788 wxPyEndAllowThreads(__tstate);
48789 if (PyErr_Occurred()) SWIG_fail;
48790 }
48791 resultobj = SWIG_Py_Void();
48792 return resultobj;
48793 fail:
48794 return NULL;
48795 }
48796
48797
48798 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48799 PyObject *resultobj = 0;
48800 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48801 int arg2 ;
48802 void *argp1 = 0 ;
48803 int res1 = 0 ;
48804 int val2 ;
48805 int ecode2 = 0 ;
48806 PyObject * obj0 = 0 ;
48807 PyObject * obj1 = 0 ;
48808 char * kwnames[] = {
48809 (char *) "self",(char *) "n", NULL
48810 };
48811
48812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48814 if (!SWIG_IsOK(res1)) {
48815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48816 }
48817 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48818 ecode2 = SWIG_AsVal_int(obj1, &val2);
48819 if (!SWIG_IsOK(ecode2)) {
48820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48821 }
48822 arg2 = static_cast< int >(val2);
48823 {
48824 PyThreadState* __tstate = wxPyBeginAllowThreads();
48825 (arg1)->Delete(arg2);
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_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48837 PyObject *resultobj = 0;
48838 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48839 int arg2 ;
48840 PyObject *result = 0 ;
48841 void *argp1 = 0 ;
48842 int res1 = 0 ;
48843 int val2 ;
48844 int ecode2 = 0 ;
48845 PyObject * obj0 = 0 ;
48846 PyObject * obj1 = 0 ;
48847 char * kwnames[] = {
48848 (char *) "self",(char *) "n", NULL
48849 };
48850
48851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48853 if (!SWIG_IsOK(res1)) {
48854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48855 }
48856 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48857 ecode2 = SWIG_AsVal_int(obj1, &val2);
48858 if (!SWIG_IsOK(ecode2)) {
48859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48860 }
48861 arg2 = static_cast< int >(val2);
48862 {
48863 PyThreadState* __tstate = wxPyBeginAllowThreads();
48864 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48865 wxPyEndAllowThreads(__tstate);
48866 if (PyErr_Occurred()) SWIG_fail;
48867 }
48868 resultobj = result;
48869 return resultobj;
48870 fail:
48871 return NULL;
48872 }
48873
48874
48875 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48876 PyObject *resultobj = 0;
48877 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48878 int arg2 ;
48879 PyObject *arg3 = (PyObject *) 0 ;
48880 void *argp1 = 0 ;
48881 int res1 = 0 ;
48882 int val2 ;
48883 int ecode2 = 0 ;
48884 PyObject * obj0 = 0 ;
48885 PyObject * obj1 = 0 ;
48886 PyObject * obj2 = 0 ;
48887 char * kwnames[] = {
48888 (char *) "self",(char *) "n",(char *) "clientData", NULL
48889 };
48890
48891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48893 if (!SWIG_IsOK(res1)) {
48894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48895 }
48896 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48897 ecode2 = SWIG_AsVal_int(obj1, &val2);
48898 if (!SWIG_IsOK(ecode2)) {
48899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48900 }
48901 arg2 = static_cast< int >(val2);
48902 arg3 = obj2;
48903 {
48904 PyThreadState* __tstate = wxPyBeginAllowThreads();
48905 wxItemContainer_SetClientData(arg1,arg2,arg3);
48906 wxPyEndAllowThreads(__tstate);
48907 if (PyErr_Occurred()) SWIG_fail;
48908 }
48909 resultobj = SWIG_Py_Void();
48910 return resultobj;
48911 fail:
48912 return NULL;
48913 }
48914
48915
48916 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48917 PyObject *resultobj = 0;
48918 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48919 int result;
48920 void *argp1 = 0 ;
48921 int res1 = 0 ;
48922 PyObject *swig_obj[1] ;
48923
48924 if (!args) SWIG_fail;
48925 swig_obj[0] = args;
48926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48927 if (!SWIG_IsOK(res1)) {
48928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48929 }
48930 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48931 {
48932 PyThreadState* __tstate = wxPyBeginAllowThreads();
48933 result = (int)((wxItemContainer const *)arg1)->GetCount();
48934 wxPyEndAllowThreads(__tstate);
48935 if (PyErr_Occurred()) SWIG_fail;
48936 }
48937 resultobj = SWIG_From_int(static_cast< int >(result));
48938 return resultobj;
48939 fail:
48940 return NULL;
48941 }
48942
48943
48944 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48945 PyObject *resultobj = 0;
48946 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48947 bool result;
48948 void *argp1 = 0 ;
48949 int res1 = 0 ;
48950 PyObject *swig_obj[1] ;
48951
48952 if (!args) SWIG_fail;
48953 swig_obj[0] = args;
48954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48955 if (!SWIG_IsOK(res1)) {
48956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48957 }
48958 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48959 {
48960 PyThreadState* __tstate = wxPyBeginAllowThreads();
48961 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48962 wxPyEndAllowThreads(__tstate);
48963 if (PyErr_Occurred()) SWIG_fail;
48964 }
48965 {
48966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48967 }
48968 return resultobj;
48969 fail:
48970 return NULL;
48971 }
48972
48973
48974 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48975 PyObject *resultobj = 0;
48976 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48977 int arg2 ;
48978 wxString result;
48979 void *argp1 = 0 ;
48980 int res1 = 0 ;
48981 int val2 ;
48982 int ecode2 = 0 ;
48983 PyObject * obj0 = 0 ;
48984 PyObject * obj1 = 0 ;
48985 char * kwnames[] = {
48986 (char *) "self",(char *) "n", NULL
48987 };
48988
48989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48991 if (!SWIG_IsOK(res1)) {
48992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48993 }
48994 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48995 ecode2 = SWIG_AsVal_int(obj1, &val2);
48996 if (!SWIG_IsOK(ecode2)) {
48997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48998 }
48999 arg2 = static_cast< int >(val2);
49000 {
49001 PyThreadState* __tstate = wxPyBeginAllowThreads();
49002 result = ((wxItemContainer const *)arg1)->GetString(arg2);
49003 wxPyEndAllowThreads(__tstate);
49004 if (PyErr_Occurred()) SWIG_fail;
49005 }
49006 {
49007 #if wxUSE_UNICODE
49008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
49009 #else
49010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
49011 #endif
49012 }
49013 return resultobj;
49014 fail:
49015 return NULL;
49016 }
49017
49018
49019 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49020 PyObject *resultobj = 0;
49021 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49022 wxArrayString result;
49023 void *argp1 = 0 ;
49024 int res1 = 0 ;
49025 PyObject *swig_obj[1] ;
49026
49027 if (!args) SWIG_fail;
49028 swig_obj[0] = args;
49029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49030 if (!SWIG_IsOK(res1)) {
49031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49032 }
49033 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49034 {
49035 PyThreadState* __tstate = wxPyBeginAllowThreads();
49036 result = ((wxItemContainer const *)arg1)->GetStrings();
49037 wxPyEndAllowThreads(__tstate);
49038 if (PyErr_Occurred()) SWIG_fail;
49039 }
49040 {
49041 resultobj = wxArrayString2PyList_helper(result);
49042 }
49043 return resultobj;
49044 fail:
49045 return NULL;
49046 }
49047
49048
49049 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49050 PyObject *resultobj = 0;
49051 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49052 int arg2 ;
49053 wxString *arg3 = 0 ;
49054 void *argp1 = 0 ;
49055 int res1 = 0 ;
49056 int val2 ;
49057 int ecode2 = 0 ;
49058 bool temp3 = false ;
49059 PyObject * obj0 = 0 ;
49060 PyObject * obj1 = 0 ;
49061 PyObject * obj2 = 0 ;
49062 char * kwnames[] = {
49063 (char *) "self",(char *) "n",(char *) "s", NULL
49064 };
49065
49066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49068 if (!SWIG_IsOK(res1)) {
49069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49070 }
49071 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49072 ecode2 = SWIG_AsVal_int(obj1, &val2);
49073 if (!SWIG_IsOK(ecode2)) {
49074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
49075 }
49076 arg2 = static_cast< int >(val2);
49077 {
49078 arg3 = wxString_in_helper(obj2);
49079 if (arg3 == NULL) SWIG_fail;
49080 temp3 = true;
49081 }
49082 {
49083 PyThreadState* __tstate = wxPyBeginAllowThreads();
49084 (arg1)->SetString(arg2,(wxString const &)*arg3);
49085 wxPyEndAllowThreads(__tstate);
49086 if (PyErr_Occurred()) SWIG_fail;
49087 }
49088 resultobj = SWIG_Py_Void();
49089 {
49090 if (temp3)
49091 delete arg3;
49092 }
49093 return resultobj;
49094 fail:
49095 {
49096 if (temp3)
49097 delete arg3;
49098 }
49099 return NULL;
49100 }
49101
49102
49103 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49104 PyObject *resultobj = 0;
49105 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49106 wxString *arg2 = 0 ;
49107 int result;
49108 void *argp1 = 0 ;
49109 int res1 = 0 ;
49110 bool temp2 = false ;
49111 PyObject * obj0 = 0 ;
49112 PyObject * obj1 = 0 ;
49113 char * kwnames[] = {
49114 (char *) "self",(char *) "s", NULL
49115 };
49116
49117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
49118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49119 if (!SWIG_IsOK(res1)) {
49120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49121 }
49122 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49123 {
49124 arg2 = wxString_in_helper(obj1);
49125 if (arg2 == NULL) SWIG_fail;
49126 temp2 = true;
49127 }
49128 {
49129 PyThreadState* __tstate = wxPyBeginAllowThreads();
49130 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
49131 wxPyEndAllowThreads(__tstate);
49132 if (PyErr_Occurred()) SWIG_fail;
49133 }
49134 resultobj = SWIG_From_int(static_cast< int >(result));
49135 {
49136 if (temp2)
49137 delete arg2;
49138 }
49139 return resultobj;
49140 fail:
49141 {
49142 if (temp2)
49143 delete arg2;
49144 }
49145 return NULL;
49146 }
49147
49148
49149 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49150 PyObject *resultobj = 0;
49151 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49152 int arg2 ;
49153 void *argp1 = 0 ;
49154 int res1 = 0 ;
49155 int val2 ;
49156 int ecode2 = 0 ;
49157 PyObject * obj0 = 0 ;
49158 PyObject * obj1 = 0 ;
49159 char * kwnames[] = {
49160 (char *) "self",(char *) "n", NULL
49161 };
49162
49163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49165 if (!SWIG_IsOK(res1)) {
49166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49167 }
49168 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49169 ecode2 = SWIG_AsVal_int(obj1, &val2);
49170 if (!SWIG_IsOK(ecode2)) {
49171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
49172 }
49173 arg2 = static_cast< int >(val2);
49174 {
49175 PyThreadState* __tstate = wxPyBeginAllowThreads();
49176 (arg1)->SetSelection(arg2);
49177 wxPyEndAllowThreads(__tstate);
49178 if (PyErr_Occurred()) SWIG_fail;
49179 }
49180 resultobj = SWIG_Py_Void();
49181 return resultobj;
49182 fail:
49183 return NULL;
49184 }
49185
49186
49187 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49188 PyObject *resultobj = 0;
49189 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49190 int result;
49191 void *argp1 = 0 ;
49192 int res1 = 0 ;
49193 PyObject *swig_obj[1] ;
49194
49195 if (!args) SWIG_fail;
49196 swig_obj[0] = args;
49197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49198 if (!SWIG_IsOK(res1)) {
49199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49200 }
49201 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49202 {
49203 PyThreadState* __tstate = wxPyBeginAllowThreads();
49204 result = (int)((wxItemContainer const *)arg1)->GetSelection();
49205 wxPyEndAllowThreads(__tstate);
49206 if (PyErr_Occurred()) SWIG_fail;
49207 }
49208 resultobj = SWIG_From_int(static_cast< int >(result));
49209 return resultobj;
49210 fail:
49211 return NULL;
49212 }
49213
49214
49215 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49216 PyObject *resultobj = 0;
49217 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49218 wxString *arg2 = 0 ;
49219 bool result;
49220 void *argp1 = 0 ;
49221 int res1 = 0 ;
49222 bool temp2 = false ;
49223 PyObject * obj0 = 0 ;
49224 PyObject * obj1 = 0 ;
49225 char * kwnames[] = {
49226 (char *) "self",(char *) "s", NULL
49227 };
49228
49229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49231 if (!SWIG_IsOK(res1)) {
49232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49233 }
49234 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49235 {
49236 arg2 = wxString_in_helper(obj1);
49237 if (arg2 == NULL) SWIG_fail;
49238 temp2 = true;
49239 }
49240 {
49241 PyThreadState* __tstate = wxPyBeginAllowThreads();
49242 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
49243 wxPyEndAllowThreads(__tstate);
49244 if (PyErr_Occurred()) SWIG_fail;
49245 }
49246 {
49247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49248 }
49249 {
49250 if (temp2)
49251 delete arg2;
49252 }
49253 return resultobj;
49254 fail:
49255 {
49256 if (temp2)
49257 delete arg2;
49258 }
49259 return NULL;
49260 }
49261
49262
49263 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49264 PyObject *resultobj = 0;
49265 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49266 wxString result;
49267 void *argp1 = 0 ;
49268 int res1 = 0 ;
49269 PyObject *swig_obj[1] ;
49270
49271 if (!args) SWIG_fail;
49272 swig_obj[0] = args;
49273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49274 if (!SWIG_IsOK(res1)) {
49275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49276 }
49277 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49278 {
49279 PyThreadState* __tstate = wxPyBeginAllowThreads();
49280 result = ((wxItemContainer const *)arg1)->GetStringSelection();
49281 wxPyEndAllowThreads(__tstate);
49282 if (PyErr_Occurred()) SWIG_fail;
49283 }
49284 {
49285 #if wxUSE_UNICODE
49286 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
49287 #else
49288 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
49289 #endif
49290 }
49291 return resultobj;
49292 fail:
49293 return NULL;
49294 }
49295
49296
49297 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49298 PyObject *resultobj = 0;
49299 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49300 int arg2 ;
49301 void *argp1 = 0 ;
49302 int res1 = 0 ;
49303 int val2 ;
49304 int ecode2 = 0 ;
49305 PyObject * obj0 = 0 ;
49306 PyObject * obj1 = 0 ;
49307 char * kwnames[] = {
49308 (char *) "self",(char *) "n", NULL
49309 };
49310
49311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
49312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49313 if (!SWIG_IsOK(res1)) {
49314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49315 }
49316 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49317 ecode2 = SWIG_AsVal_int(obj1, &val2);
49318 if (!SWIG_IsOK(ecode2)) {
49319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
49320 }
49321 arg2 = static_cast< int >(val2);
49322 {
49323 PyThreadState* __tstate = wxPyBeginAllowThreads();
49324 (arg1)->Select(arg2);
49325 wxPyEndAllowThreads(__tstate);
49326 if (PyErr_Occurred()) SWIG_fail;
49327 }
49328 resultobj = SWIG_Py_Void();
49329 return resultobj;
49330 fail:
49331 return NULL;
49332 }
49333
49334
49335 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49336 PyObject *obj;
49337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49338 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
49339 return SWIG_Py_Void();
49340 }
49341
49342 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49343 PyObject *obj;
49344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49345 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
49346 return SWIG_Py_Void();
49347 }
49348
49349 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49350 PyObject *resultobj = 0;
49351 int arg1 = (int) 0 ;
49352 wxSizerFlags *result = 0 ;
49353 int val1 ;
49354 int ecode1 = 0 ;
49355 PyObject * obj0 = 0 ;
49356 char * kwnames[] = {
49357 (char *) "proportion", NULL
49358 };
49359
49360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
49361 if (obj0) {
49362 ecode1 = SWIG_AsVal_int(obj0, &val1);
49363 if (!SWIG_IsOK(ecode1)) {
49364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
49365 }
49366 arg1 = static_cast< int >(val1);
49367 }
49368 {
49369 PyThreadState* __tstate = wxPyBeginAllowThreads();
49370 result = (wxSizerFlags *)new wxSizerFlags(arg1);
49371 wxPyEndAllowThreads(__tstate);
49372 if (PyErr_Occurred()) SWIG_fail;
49373 }
49374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
49375 return resultobj;
49376 fail:
49377 return NULL;
49378 }
49379
49380
49381 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49382 PyObject *resultobj = 0;
49383 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49384 void *argp1 = 0 ;
49385 int res1 = 0 ;
49386 PyObject *swig_obj[1] ;
49387
49388 if (!args) SWIG_fail;
49389 swig_obj[0] = args;
49390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
49391 if (!SWIG_IsOK(res1)) {
49392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49393 }
49394 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49395 {
49396 PyThreadState* __tstate = wxPyBeginAllowThreads();
49397 delete arg1;
49398
49399 wxPyEndAllowThreads(__tstate);
49400 if (PyErr_Occurred()) SWIG_fail;
49401 }
49402 resultobj = SWIG_Py_Void();
49403 return resultobj;
49404 fail:
49405 return NULL;
49406 }
49407
49408
49409 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49410 PyObject *resultobj = 0;
49411 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49412 int arg2 ;
49413 wxSizerFlags *result = 0 ;
49414 void *argp1 = 0 ;
49415 int res1 = 0 ;
49416 int val2 ;
49417 int ecode2 = 0 ;
49418 PyObject * obj0 = 0 ;
49419 PyObject * obj1 = 0 ;
49420 char * kwnames[] = {
49421 (char *) "self",(char *) "proportion", NULL
49422 };
49423
49424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
49425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49426 if (!SWIG_IsOK(res1)) {
49427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49428 }
49429 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49430 ecode2 = SWIG_AsVal_int(obj1, &val2);
49431 if (!SWIG_IsOK(ecode2)) {
49432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
49433 }
49434 arg2 = static_cast< int >(val2);
49435 {
49436 PyThreadState* __tstate = wxPyBeginAllowThreads();
49437 {
49438 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
49439 result = (wxSizerFlags *) &_result_ref;
49440 }
49441 wxPyEndAllowThreads(__tstate);
49442 if (PyErr_Occurred()) SWIG_fail;
49443 }
49444 {
49445 resultobj = obj0; Py_INCREF(resultobj);
49446 }
49447 return resultobj;
49448 fail:
49449 return NULL;
49450 }
49451
49452
49453 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49454 PyObject *resultobj = 0;
49455 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49456 int arg2 ;
49457 wxSizerFlags *result = 0 ;
49458 void *argp1 = 0 ;
49459 int res1 = 0 ;
49460 int val2 ;
49461 int ecode2 = 0 ;
49462 PyObject * obj0 = 0 ;
49463 PyObject * obj1 = 0 ;
49464 char * kwnames[] = {
49465 (char *) "self",(char *) "alignment", NULL
49466 };
49467
49468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
49469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49470 if (!SWIG_IsOK(res1)) {
49471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49472 }
49473 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49474 ecode2 = SWIG_AsVal_int(obj1, &val2);
49475 if (!SWIG_IsOK(ecode2)) {
49476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
49477 }
49478 arg2 = static_cast< int >(val2);
49479 {
49480 PyThreadState* __tstate = wxPyBeginAllowThreads();
49481 {
49482 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
49483 result = (wxSizerFlags *) &_result_ref;
49484 }
49485 wxPyEndAllowThreads(__tstate);
49486 if (PyErr_Occurred()) SWIG_fail;
49487 }
49488 {
49489 resultobj = obj0; Py_INCREF(resultobj);
49490 }
49491 return resultobj;
49492 fail:
49493 return NULL;
49494 }
49495
49496
49497 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49498 PyObject *resultobj = 0;
49499 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49500 wxSizerFlags *result = 0 ;
49501 void *argp1 = 0 ;
49502 int res1 = 0 ;
49503 PyObject *swig_obj[1] ;
49504
49505 if (!args) SWIG_fail;
49506 swig_obj[0] = args;
49507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49508 if (!SWIG_IsOK(res1)) {
49509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49510 }
49511 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49512 {
49513 PyThreadState* __tstate = wxPyBeginAllowThreads();
49514 {
49515 wxSizerFlags &_result_ref = (arg1)->Expand();
49516 result = (wxSizerFlags *) &_result_ref;
49517 }
49518 wxPyEndAllowThreads(__tstate);
49519 if (PyErr_Occurred()) SWIG_fail;
49520 }
49521 {
49522 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49523 }
49524 return resultobj;
49525 fail:
49526 return NULL;
49527 }
49528
49529
49530 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49531 PyObject *resultobj = 0;
49532 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49533 wxSizerFlags *result = 0 ;
49534 void *argp1 = 0 ;
49535 int res1 = 0 ;
49536 PyObject *swig_obj[1] ;
49537
49538 if (!args) SWIG_fail;
49539 swig_obj[0] = args;
49540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49541 if (!SWIG_IsOK(res1)) {
49542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49543 }
49544 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49545 {
49546 PyThreadState* __tstate = wxPyBeginAllowThreads();
49547 {
49548 wxSizerFlags &_result_ref = (arg1)->Centre();
49549 result = (wxSizerFlags *) &_result_ref;
49550 }
49551 wxPyEndAllowThreads(__tstate);
49552 if (PyErr_Occurred()) SWIG_fail;
49553 }
49554 {
49555 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49556 }
49557 return resultobj;
49558 fail:
49559 return NULL;
49560 }
49561
49562
49563 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49564 PyObject *resultobj = 0;
49565 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49566 wxSizerFlags *result = 0 ;
49567 void *argp1 = 0 ;
49568 int res1 = 0 ;
49569 PyObject *swig_obj[1] ;
49570
49571 if (!args) SWIG_fail;
49572 swig_obj[0] = args;
49573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49574 if (!SWIG_IsOK(res1)) {
49575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49576 }
49577 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49578 {
49579 PyThreadState* __tstate = wxPyBeginAllowThreads();
49580 {
49581 wxSizerFlags &_result_ref = (arg1)->Center();
49582 result = (wxSizerFlags *) &_result_ref;
49583 }
49584 wxPyEndAllowThreads(__tstate);
49585 if (PyErr_Occurred()) SWIG_fail;
49586 }
49587 {
49588 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49589 }
49590 return resultobj;
49591 fail:
49592 return NULL;
49593 }
49594
49595
49596 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49597 PyObject *resultobj = 0;
49598 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49599 wxSizerFlags *result = 0 ;
49600 void *argp1 = 0 ;
49601 int res1 = 0 ;
49602 PyObject *swig_obj[1] ;
49603
49604 if (!args) SWIG_fail;
49605 swig_obj[0] = args;
49606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49607 if (!SWIG_IsOK(res1)) {
49608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49609 }
49610 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49611 {
49612 PyThreadState* __tstate = wxPyBeginAllowThreads();
49613 {
49614 wxSizerFlags &_result_ref = (arg1)->Left();
49615 result = (wxSizerFlags *) &_result_ref;
49616 }
49617 wxPyEndAllowThreads(__tstate);
49618 if (PyErr_Occurred()) SWIG_fail;
49619 }
49620 {
49621 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49622 }
49623 return resultobj;
49624 fail:
49625 return NULL;
49626 }
49627
49628
49629 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49630 PyObject *resultobj = 0;
49631 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49632 wxSizerFlags *result = 0 ;
49633 void *argp1 = 0 ;
49634 int res1 = 0 ;
49635 PyObject *swig_obj[1] ;
49636
49637 if (!args) SWIG_fail;
49638 swig_obj[0] = args;
49639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49640 if (!SWIG_IsOK(res1)) {
49641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49642 }
49643 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49644 {
49645 PyThreadState* __tstate = wxPyBeginAllowThreads();
49646 {
49647 wxSizerFlags &_result_ref = (arg1)->Right();
49648 result = (wxSizerFlags *) &_result_ref;
49649 }
49650 wxPyEndAllowThreads(__tstate);
49651 if (PyErr_Occurred()) SWIG_fail;
49652 }
49653 {
49654 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49655 }
49656 return resultobj;
49657 fail:
49658 return NULL;
49659 }
49660
49661
49662 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49663 PyObject *resultobj = 0;
49664 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49665 wxSizerFlags *result = 0 ;
49666 void *argp1 = 0 ;
49667 int res1 = 0 ;
49668 PyObject *swig_obj[1] ;
49669
49670 if (!args) SWIG_fail;
49671 swig_obj[0] = args;
49672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49673 if (!SWIG_IsOK(res1)) {
49674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49675 }
49676 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49677 {
49678 PyThreadState* __tstate = wxPyBeginAllowThreads();
49679 {
49680 wxSizerFlags &_result_ref = (arg1)->Top();
49681 result = (wxSizerFlags *) &_result_ref;
49682 }
49683 wxPyEndAllowThreads(__tstate);
49684 if (PyErr_Occurred()) SWIG_fail;
49685 }
49686 {
49687 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49688 }
49689 return resultobj;
49690 fail:
49691 return NULL;
49692 }
49693
49694
49695 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49696 PyObject *resultobj = 0;
49697 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49698 wxSizerFlags *result = 0 ;
49699 void *argp1 = 0 ;
49700 int res1 = 0 ;
49701 PyObject *swig_obj[1] ;
49702
49703 if (!args) SWIG_fail;
49704 swig_obj[0] = args;
49705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49706 if (!SWIG_IsOK(res1)) {
49707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49708 }
49709 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49710 {
49711 PyThreadState* __tstate = wxPyBeginAllowThreads();
49712 {
49713 wxSizerFlags &_result_ref = (arg1)->Bottom();
49714 result = (wxSizerFlags *) &_result_ref;
49715 }
49716 wxPyEndAllowThreads(__tstate);
49717 if (PyErr_Occurred()) SWIG_fail;
49718 }
49719 {
49720 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49721 }
49722 return resultobj;
49723 fail:
49724 return NULL;
49725 }
49726
49727
49728 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49729 PyObject *resultobj = 0;
49730 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49731 wxSizerFlags *result = 0 ;
49732 void *argp1 = 0 ;
49733 int res1 = 0 ;
49734 PyObject *swig_obj[1] ;
49735
49736 if (!args) SWIG_fail;
49737 swig_obj[0] = args;
49738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49739 if (!SWIG_IsOK(res1)) {
49740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49741 }
49742 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49743 {
49744 PyThreadState* __tstate = wxPyBeginAllowThreads();
49745 {
49746 wxSizerFlags &_result_ref = (arg1)->Shaped();
49747 result = (wxSizerFlags *) &_result_ref;
49748 }
49749 wxPyEndAllowThreads(__tstate);
49750 if (PyErr_Occurred()) SWIG_fail;
49751 }
49752 {
49753 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49754 }
49755 return resultobj;
49756 fail:
49757 return NULL;
49758 }
49759
49760
49761 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49762 PyObject *resultobj = 0;
49763 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49764 wxSizerFlags *result = 0 ;
49765 void *argp1 = 0 ;
49766 int res1 = 0 ;
49767 PyObject *swig_obj[1] ;
49768
49769 if (!args) SWIG_fail;
49770 swig_obj[0] = args;
49771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49772 if (!SWIG_IsOK(res1)) {
49773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49774 }
49775 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49776 {
49777 PyThreadState* __tstate = wxPyBeginAllowThreads();
49778 {
49779 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49780 result = (wxSizerFlags *) &_result_ref;
49781 }
49782 wxPyEndAllowThreads(__tstate);
49783 if (PyErr_Occurred()) SWIG_fail;
49784 }
49785 {
49786 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49787 }
49788 return resultobj;
49789 fail:
49790 return NULL;
49791 }
49792
49793
49794 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49795 PyObject *resultobj = 0;
49796 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49797 int arg2 = (int) wxALL ;
49798 int arg3 = (int) -1 ;
49799 wxSizerFlags *result = 0 ;
49800 void *argp1 = 0 ;
49801 int res1 = 0 ;
49802 int val2 ;
49803 int ecode2 = 0 ;
49804 int val3 ;
49805 int ecode3 = 0 ;
49806 PyObject * obj0 = 0 ;
49807 PyObject * obj1 = 0 ;
49808 PyObject * obj2 = 0 ;
49809 char * kwnames[] = {
49810 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49811 };
49812
49813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49815 if (!SWIG_IsOK(res1)) {
49816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49817 }
49818 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49819 if (obj1) {
49820 ecode2 = SWIG_AsVal_int(obj1, &val2);
49821 if (!SWIG_IsOK(ecode2)) {
49822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49823 }
49824 arg2 = static_cast< int >(val2);
49825 }
49826 if (obj2) {
49827 ecode3 = SWIG_AsVal_int(obj2, &val3);
49828 if (!SWIG_IsOK(ecode3)) {
49829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49830 }
49831 arg3 = static_cast< int >(val3);
49832 }
49833 {
49834 PyThreadState* __tstate = wxPyBeginAllowThreads();
49835 {
49836 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49837 result = (wxSizerFlags *) &_result_ref;
49838 }
49839 wxPyEndAllowThreads(__tstate);
49840 if (PyErr_Occurred()) SWIG_fail;
49841 }
49842 {
49843 resultobj = obj0; Py_INCREF(resultobj);
49844 }
49845 return resultobj;
49846 fail:
49847 return NULL;
49848 }
49849
49850
49851 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49852 PyObject *resultobj = 0;
49853 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49854 int arg2 = (int) wxALL ;
49855 wxSizerFlags *result = 0 ;
49856 void *argp1 = 0 ;
49857 int res1 = 0 ;
49858 int val2 ;
49859 int ecode2 = 0 ;
49860 PyObject * obj0 = 0 ;
49861 PyObject * obj1 = 0 ;
49862 char * kwnames[] = {
49863 (char *) "self",(char *) "direction", NULL
49864 };
49865
49866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49868 if (!SWIG_IsOK(res1)) {
49869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49870 }
49871 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49872 if (obj1) {
49873 ecode2 = SWIG_AsVal_int(obj1, &val2);
49874 if (!SWIG_IsOK(ecode2)) {
49875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49876 }
49877 arg2 = static_cast< int >(val2);
49878 }
49879 {
49880 PyThreadState* __tstate = wxPyBeginAllowThreads();
49881 {
49882 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49883 result = (wxSizerFlags *) &_result_ref;
49884 }
49885 wxPyEndAllowThreads(__tstate);
49886 if (PyErr_Occurred()) SWIG_fail;
49887 }
49888 {
49889 resultobj = obj0; Py_INCREF(resultobj);
49890 }
49891 return resultobj;
49892 fail:
49893 return NULL;
49894 }
49895
49896
49897 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49898 PyObject *resultobj = 0;
49899 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49900 int arg2 = (int) wxALL ;
49901 wxSizerFlags *result = 0 ;
49902 void *argp1 = 0 ;
49903 int res1 = 0 ;
49904 int val2 ;
49905 int ecode2 = 0 ;
49906 PyObject * obj0 = 0 ;
49907 PyObject * obj1 = 0 ;
49908 char * kwnames[] = {
49909 (char *) "self",(char *) "direction", NULL
49910 };
49911
49912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49914 if (!SWIG_IsOK(res1)) {
49915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49916 }
49917 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49918 if (obj1) {
49919 ecode2 = SWIG_AsVal_int(obj1, &val2);
49920 if (!SWIG_IsOK(ecode2)) {
49921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49922 }
49923 arg2 = static_cast< int >(val2);
49924 }
49925 {
49926 PyThreadState* __tstate = wxPyBeginAllowThreads();
49927 {
49928 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49929 result = (wxSizerFlags *) &_result_ref;
49930 }
49931 wxPyEndAllowThreads(__tstate);
49932 if (PyErr_Occurred()) SWIG_fail;
49933 }
49934 {
49935 resultobj = obj0; Py_INCREF(resultobj);
49936 }
49937 return resultobj;
49938 fail:
49939 return NULL;
49940 }
49941
49942
49943 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49944 PyObject *resultobj = 0;
49945 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49946 wxSizerFlags *result = 0 ;
49947 void *argp1 = 0 ;
49948 int res1 = 0 ;
49949 PyObject *swig_obj[1] ;
49950
49951 if (!args) SWIG_fail;
49952 swig_obj[0] = args;
49953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49954 if (!SWIG_IsOK(res1)) {
49955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49956 }
49957 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49958 {
49959 PyThreadState* __tstate = wxPyBeginAllowThreads();
49960 {
49961 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49962 result = (wxSizerFlags *) &_result_ref;
49963 }
49964 wxPyEndAllowThreads(__tstate);
49965 if (PyErr_Occurred()) SWIG_fail;
49966 }
49967 {
49968 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49969 }
49970 return resultobj;
49971 fail:
49972 return NULL;
49973 }
49974
49975
49976 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49977 PyObject *resultobj = 0;
49978 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49979 wxSizerFlags *result = 0 ;
49980 void *argp1 = 0 ;
49981 int res1 = 0 ;
49982 PyObject *swig_obj[1] ;
49983
49984 if (!args) SWIG_fail;
49985 swig_obj[0] = args;
49986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49987 if (!SWIG_IsOK(res1)) {
49988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49989 }
49990 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49991 {
49992 PyThreadState* __tstate = wxPyBeginAllowThreads();
49993 {
49994 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49995 result = (wxSizerFlags *) &_result_ref;
49996 }
49997 wxPyEndAllowThreads(__tstate);
49998 if (PyErr_Occurred()) SWIG_fail;
49999 }
50000 {
50001 resultobj = swig_obj[0]; Py_INCREF(resultobj);
50002 }
50003 return resultobj;
50004 fail:
50005 return NULL;
50006 }
50007
50008
50009 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50010 PyObject *resultobj = 0;
50011 int result;
50012
50013 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
50014 {
50015 PyThreadState* __tstate = wxPyBeginAllowThreads();
50016 result = (int)wxSizerFlags::GetDefaultBorder();
50017 wxPyEndAllowThreads(__tstate);
50018 if (PyErr_Occurred()) SWIG_fail;
50019 }
50020 resultobj = SWIG_From_int(static_cast< int >(result));
50021 return resultobj;
50022 fail:
50023 return NULL;
50024 }
50025
50026
50027 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50028 PyObject *resultobj = 0;
50029 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50030 int result;
50031 void *argp1 = 0 ;
50032 int res1 = 0 ;
50033 PyObject *swig_obj[1] ;
50034
50035 if (!args) SWIG_fail;
50036 swig_obj[0] = args;
50037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50038 if (!SWIG_IsOK(res1)) {
50039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50040 }
50041 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50042 {
50043 PyThreadState* __tstate = wxPyBeginAllowThreads();
50044 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
50045 wxPyEndAllowThreads(__tstate);
50046 if (PyErr_Occurred()) SWIG_fail;
50047 }
50048 resultobj = SWIG_From_int(static_cast< int >(result));
50049 return resultobj;
50050 fail:
50051 return NULL;
50052 }
50053
50054
50055 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50056 PyObject *resultobj = 0;
50057 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50058 int result;
50059 void *argp1 = 0 ;
50060 int res1 = 0 ;
50061 PyObject *swig_obj[1] ;
50062
50063 if (!args) SWIG_fail;
50064 swig_obj[0] = args;
50065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50066 if (!SWIG_IsOK(res1)) {
50067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50068 }
50069 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50070 {
50071 PyThreadState* __tstate = wxPyBeginAllowThreads();
50072 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
50073 wxPyEndAllowThreads(__tstate);
50074 if (PyErr_Occurred()) SWIG_fail;
50075 }
50076 resultobj = SWIG_From_int(static_cast< int >(result));
50077 return resultobj;
50078 fail:
50079 return NULL;
50080 }
50081
50082
50083 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50084 PyObject *resultobj = 0;
50085 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50086 int result;
50087 void *argp1 = 0 ;
50088 int res1 = 0 ;
50089 PyObject *swig_obj[1] ;
50090
50091 if (!args) SWIG_fail;
50092 swig_obj[0] = args;
50093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50094 if (!SWIG_IsOK(res1)) {
50095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50096 }
50097 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50098 {
50099 PyThreadState* __tstate = wxPyBeginAllowThreads();
50100 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
50101 wxPyEndAllowThreads(__tstate);
50102 if (PyErr_Occurred()) SWIG_fail;
50103 }
50104 resultobj = SWIG_From_int(static_cast< int >(result));
50105 return resultobj;
50106 fail:
50107 return NULL;
50108 }
50109
50110
50111 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50112 PyObject *obj;
50113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50114 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
50115 return SWIG_Py_Void();
50116 }
50117
50118 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50119 return SWIG_Python_InitShadowInstance(args);
50120 }
50121
50122 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50123 PyObject *resultobj = 0;
50124 wxSizerItem *result = 0 ;
50125
50126 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
50127 {
50128 PyThreadState* __tstate = wxPyBeginAllowThreads();
50129 result = (wxSizerItem *)new wxSizerItem();
50130 wxPyEndAllowThreads(__tstate);
50131 if (PyErr_Occurred()) SWIG_fail;
50132 }
50133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
50134 return resultobj;
50135 fail:
50136 return NULL;
50137 }
50138
50139
50140 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50141 PyObject *resultobj = 0;
50142 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50143 void *argp1 = 0 ;
50144 int res1 = 0 ;
50145 PyObject *swig_obj[1] ;
50146
50147 if (!args) SWIG_fail;
50148 swig_obj[0] = args;
50149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50150 if (!SWIG_IsOK(res1)) {
50151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50152 }
50153 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50154 {
50155 PyThreadState* __tstate = wxPyBeginAllowThreads();
50156 delete arg1;
50157
50158 wxPyEndAllowThreads(__tstate);
50159 if (PyErr_Occurred()) SWIG_fail;
50160 }
50161 resultobj = SWIG_Py_Void();
50162 return resultobj;
50163 fail:
50164 return NULL;
50165 }
50166
50167
50168 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50169 PyObject *resultobj = 0;
50170 wxWindow *arg1 = (wxWindow *) 0 ;
50171 int arg2 ;
50172 int arg3 ;
50173 int arg4 ;
50174 PyObject *arg5 = (PyObject *) NULL ;
50175 wxSizerItem *result = 0 ;
50176 void *argp1 = 0 ;
50177 int res1 = 0 ;
50178 int val2 ;
50179 int ecode2 = 0 ;
50180 int val3 ;
50181 int ecode3 = 0 ;
50182 int val4 ;
50183 int ecode4 = 0 ;
50184 PyObject * obj0 = 0 ;
50185 PyObject * obj1 = 0 ;
50186 PyObject * obj2 = 0 ;
50187 PyObject * obj3 = 0 ;
50188 PyObject * obj4 = 0 ;
50189 char * kwnames[] = {
50190 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50191 };
50192
50193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50195 if (!SWIG_IsOK(res1)) {
50196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50197 }
50198 arg1 = reinterpret_cast< wxWindow * >(argp1);
50199 ecode2 = SWIG_AsVal_int(obj1, &val2);
50200 if (!SWIG_IsOK(ecode2)) {
50201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
50202 }
50203 arg2 = static_cast< int >(val2);
50204 ecode3 = SWIG_AsVal_int(obj2, &val3);
50205 if (!SWIG_IsOK(ecode3)) {
50206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
50207 }
50208 arg3 = static_cast< int >(val3);
50209 ecode4 = SWIG_AsVal_int(obj3, &val4);
50210 if (!SWIG_IsOK(ecode4)) {
50211 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50212 }
50213 arg4 = static_cast< int >(val4);
50214 if (obj4) {
50215 arg5 = obj4;
50216 }
50217 {
50218 PyThreadState* __tstate = wxPyBeginAllowThreads();
50219 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50220 wxPyEndAllowThreads(__tstate);
50221 if (PyErr_Occurred()) SWIG_fail;
50222 }
50223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50224 return resultobj;
50225 fail:
50226 return NULL;
50227 }
50228
50229
50230 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50231 PyObject *resultobj = 0;
50232 int arg1 ;
50233 int arg2 ;
50234 int arg3 ;
50235 int arg4 ;
50236 int arg5 ;
50237 PyObject *arg6 = (PyObject *) NULL ;
50238 wxSizerItem *result = 0 ;
50239 int val1 ;
50240 int ecode1 = 0 ;
50241 int val2 ;
50242 int ecode2 = 0 ;
50243 int val3 ;
50244 int ecode3 = 0 ;
50245 int val4 ;
50246 int ecode4 = 0 ;
50247 int val5 ;
50248 int ecode5 = 0 ;
50249 PyObject * obj0 = 0 ;
50250 PyObject * obj1 = 0 ;
50251 PyObject * obj2 = 0 ;
50252 PyObject * obj3 = 0 ;
50253 PyObject * obj4 = 0 ;
50254 PyObject * obj5 = 0 ;
50255 char * kwnames[] = {
50256 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50257 };
50258
50259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50260 ecode1 = SWIG_AsVal_int(obj0, &val1);
50261 if (!SWIG_IsOK(ecode1)) {
50262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50263 }
50264 arg1 = static_cast< int >(val1);
50265 ecode2 = SWIG_AsVal_int(obj1, &val2);
50266 if (!SWIG_IsOK(ecode2)) {
50267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50268 }
50269 arg2 = static_cast< int >(val2);
50270 ecode3 = SWIG_AsVal_int(obj2, &val3);
50271 if (!SWIG_IsOK(ecode3)) {
50272 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
50273 }
50274 arg3 = static_cast< int >(val3);
50275 ecode4 = SWIG_AsVal_int(obj3, &val4);
50276 if (!SWIG_IsOK(ecode4)) {
50277 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
50278 }
50279 arg4 = static_cast< int >(val4);
50280 ecode5 = SWIG_AsVal_int(obj4, &val5);
50281 if (!SWIG_IsOK(ecode5)) {
50282 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50283 }
50284 arg5 = static_cast< int >(val5);
50285 if (obj5) {
50286 arg6 = obj5;
50287 }
50288 {
50289 PyThreadState* __tstate = wxPyBeginAllowThreads();
50290 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
50291 wxPyEndAllowThreads(__tstate);
50292 if (PyErr_Occurred()) SWIG_fail;
50293 }
50294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50295 return resultobj;
50296 fail:
50297 return NULL;
50298 }
50299
50300
50301 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50302 PyObject *resultobj = 0;
50303 wxSizer *arg1 = (wxSizer *) 0 ;
50304 int arg2 ;
50305 int arg3 ;
50306 int arg4 ;
50307 PyObject *arg5 = (PyObject *) NULL ;
50308 wxSizerItem *result = 0 ;
50309 int res1 = 0 ;
50310 int val2 ;
50311 int ecode2 = 0 ;
50312 int val3 ;
50313 int ecode3 = 0 ;
50314 int val4 ;
50315 int ecode4 = 0 ;
50316 PyObject * obj0 = 0 ;
50317 PyObject * obj1 = 0 ;
50318 PyObject * obj2 = 0 ;
50319 PyObject * obj3 = 0 ;
50320 PyObject * obj4 = 0 ;
50321 char * kwnames[] = {
50322 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50323 };
50324
50325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50326 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50327 if (!SWIG_IsOK(res1)) {
50328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50329 }
50330 ecode2 = SWIG_AsVal_int(obj1, &val2);
50331 if (!SWIG_IsOK(ecode2)) {
50332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
50333 }
50334 arg2 = static_cast< int >(val2);
50335 ecode3 = SWIG_AsVal_int(obj2, &val3);
50336 if (!SWIG_IsOK(ecode3)) {
50337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
50338 }
50339 arg3 = static_cast< int >(val3);
50340 ecode4 = SWIG_AsVal_int(obj3, &val4);
50341 if (!SWIG_IsOK(ecode4)) {
50342 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50343 }
50344 arg4 = static_cast< int >(val4);
50345 if (obj4) {
50346 arg5 = obj4;
50347 }
50348 {
50349 PyThreadState* __tstate = wxPyBeginAllowThreads();
50350 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50351 wxPyEndAllowThreads(__tstate);
50352 if (PyErr_Occurred()) SWIG_fail;
50353 }
50354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50355 return resultobj;
50356 fail:
50357 return NULL;
50358 }
50359
50360
50361 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50362 PyObject *resultobj = 0;
50363 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50364 void *argp1 = 0 ;
50365 int res1 = 0 ;
50366 PyObject *swig_obj[1] ;
50367
50368 if (!args) SWIG_fail;
50369 swig_obj[0] = args;
50370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50371 if (!SWIG_IsOK(res1)) {
50372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50373 }
50374 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50375 {
50376 PyThreadState* __tstate = wxPyBeginAllowThreads();
50377 (arg1)->DeleteWindows();
50378 wxPyEndAllowThreads(__tstate);
50379 if (PyErr_Occurred()) SWIG_fail;
50380 }
50381 resultobj = SWIG_Py_Void();
50382 return resultobj;
50383 fail:
50384 return NULL;
50385 }
50386
50387
50388 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50389 PyObject *resultobj = 0;
50390 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50391 void *argp1 = 0 ;
50392 int res1 = 0 ;
50393 PyObject *swig_obj[1] ;
50394
50395 if (!args) SWIG_fail;
50396 swig_obj[0] = args;
50397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50398 if (!SWIG_IsOK(res1)) {
50399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50400 }
50401 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50402 {
50403 PyThreadState* __tstate = wxPyBeginAllowThreads();
50404 (arg1)->DetachSizer();
50405 wxPyEndAllowThreads(__tstate);
50406 if (PyErr_Occurred()) SWIG_fail;
50407 }
50408 resultobj = SWIG_Py_Void();
50409 return resultobj;
50410 fail:
50411 return NULL;
50412 }
50413
50414
50415 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50416 PyObject *resultobj = 0;
50417 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50418 wxSize result;
50419 void *argp1 = 0 ;
50420 int res1 = 0 ;
50421 PyObject *swig_obj[1] ;
50422
50423 if (!args) SWIG_fail;
50424 swig_obj[0] = args;
50425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50426 if (!SWIG_IsOK(res1)) {
50427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50428 }
50429 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50430 {
50431 PyThreadState* __tstate = wxPyBeginAllowThreads();
50432 result = (arg1)->GetSize();
50433 wxPyEndAllowThreads(__tstate);
50434 if (PyErr_Occurred()) SWIG_fail;
50435 }
50436 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50437 return resultobj;
50438 fail:
50439 return NULL;
50440 }
50441
50442
50443 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50444 PyObject *resultobj = 0;
50445 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50446 wxSize result;
50447 void *argp1 = 0 ;
50448 int res1 = 0 ;
50449 PyObject *swig_obj[1] ;
50450
50451 if (!args) SWIG_fail;
50452 swig_obj[0] = args;
50453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50454 if (!SWIG_IsOK(res1)) {
50455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50456 }
50457 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50458 {
50459 PyThreadState* __tstate = wxPyBeginAllowThreads();
50460 result = (arg1)->CalcMin();
50461 wxPyEndAllowThreads(__tstate);
50462 if (PyErr_Occurred()) SWIG_fail;
50463 }
50464 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50465 return resultobj;
50466 fail:
50467 return NULL;
50468 }
50469
50470
50471 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50472 PyObject *resultobj = 0;
50473 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50474 wxPoint *arg2 = 0 ;
50475 wxSize *arg3 = 0 ;
50476 void *argp1 = 0 ;
50477 int res1 = 0 ;
50478 wxPoint temp2 ;
50479 wxSize temp3 ;
50480 PyObject * obj0 = 0 ;
50481 PyObject * obj1 = 0 ;
50482 PyObject * obj2 = 0 ;
50483 char * kwnames[] = {
50484 (char *) "self",(char *) "pos",(char *) "size", NULL
50485 };
50486
50487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50489 if (!SWIG_IsOK(res1)) {
50490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50491 }
50492 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50493 {
50494 arg2 = &temp2;
50495 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50496 }
50497 {
50498 arg3 = &temp3;
50499 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50500 }
50501 {
50502 PyThreadState* __tstate = wxPyBeginAllowThreads();
50503 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
50504 wxPyEndAllowThreads(__tstate);
50505 if (PyErr_Occurred()) SWIG_fail;
50506 }
50507 resultobj = SWIG_Py_Void();
50508 return resultobj;
50509 fail:
50510 return NULL;
50511 }
50512
50513
50514 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50515 PyObject *resultobj = 0;
50516 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50517 wxSize result;
50518 void *argp1 = 0 ;
50519 int res1 = 0 ;
50520 PyObject *swig_obj[1] ;
50521
50522 if (!args) SWIG_fail;
50523 swig_obj[0] = args;
50524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50525 if (!SWIG_IsOK(res1)) {
50526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50527 }
50528 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50529 {
50530 PyThreadState* __tstate = wxPyBeginAllowThreads();
50531 result = (arg1)->GetMinSize();
50532 wxPyEndAllowThreads(__tstate);
50533 if (PyErr_Occurred()) SWIG_fail;
50534 }
50535 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50536 return resultobj;
50537 fail:
50538 return NULL;
50539 }
50540
50541
50542 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50543 PyObject *resultobj = 0;
50544 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50545 wxSize result;
50546 void *argp1 = 0 ;
50547 int res1 = 0 ;
50548 PyObject *swig_obj[1] ;
50549
50550 if (!args) SWIG_fail;
50551 swig_obj[0] = args;
50552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50553 if (!SWIG_IsOK(res1)) {
50554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
50555 }
50556 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50557 {
50558 PyThreadState* __tstate = wxPyBeginAllowThreads();
50559 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
50560 wxPyEndAllowThreads(__tstate);
50561 if (PyErr_Occurred()) SWIG_fail;
50562 }
50563 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50564 return resultobj;
50565 fail:
50566 return NULL;
50567 }
50568
50569
50570 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50571 PyObject *resultobj = 0;
50572 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50573 int arg2 ;
50574 int arg3 ;
50575 void *argp1 = 0 ;
50576 int res1 = 0 ;
50577 int val2 ;
50578 int ecode2 = 0 ;
50579 int val3 ;
50580 int ecode3 = 0 ;
50581 PyObject * obj0 = 0 ;
50582 PyObject * obj1 = 0 ;
50583 PyObject * obj2 = 0 ;
50584 char * kwnames[] = {
50585 (char *) "self",(char *) "x",(char *) "y", NULL
50586 };
50587
50588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50590 if (!SWIG_IsOK(res1)) {
50591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50592 }
50593 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50594 ecode2 = SWIG_AsVal_int(obj1, &val2);
50595 if (!SWIG_IsOK(ecode2)) {
50596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50597 }
50598 arg2 = static_cast< int >(val2);
50599 ecode3 = SWIG_AsVal_int(obj2, &val3);
50600 if (!SWIG_IsOK(ecode3)) {
50601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50602 }
50603 arg3 = static_cast< int >(val3);
50604 {
50605 PyThreadState* __tstate = wxPyBeginAllowThreads();
50606 (arg1)->SetInitSize(arg2,arg3);
50607 wxPyEndAllowThreads(__tstate);
50608 if (PyErr_Occurred()) SWIG_fail;
50609 }
50610 resultobj = SWIG_Py_Void();
50611 return resultobj;
50612 fail:
50613 return NULL;
50614 }
50615
50616
50617 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50618 PyObject *resultobj = 0;
50619 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50620 int arg2 ;
50621 int arg3 ;
50622 void *argp1 = 0 ;
50623 int res1 = 0 ;
50624 int val2 ;
50625 int ecode2 = 0 ;
50626 int val3 ;
50627 int ecode3 = 0 ;
50628 PyObject * obj0 = 0 ;
50629 PyObject * obj1 = 0 ;
50630 PyObject * obj2 = 0 ;
50631 char * kwnames[] = {
50632 (char *) "self",(char *) "width",(char *) "height", NULL
50633 };
50634
50635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50637 if (!SWIG_IsOK(res1)) {
50638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50639 }
50640 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50641 ecode2 = SWIG_AsVal_int(obj1, &val2);
50642 if (!SWIG_IsOK(ecode2)) {
50643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50644 }
50645 arg2 = static_cast< int >(val2);
50646 ecode3 = SWIG_AsVal_int(obj2, &val3);
50647 if (!SWIG_IsOK(ecode3)) {
50648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50649 }
50650 arg3 = static_cast< int >(val3);
50651 {
50652 PyThreadState* __tstate = wxPyBeginAllowThreads();
50653 (arg1)->SetRatio(arg2,arg3);
50654 wxPyEndAllowThreads(__tstate);
50655 if (PyErr_Occurred()) SWIG_fail;
50656 }
50657 resultobj = SWIG_Py_Void();
50658 return resultobj;
50659 fail:
50660 return NULL;
50661 }
50662
50663
50664 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50665 PyObject *resultobj = 0;
50666 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50667 wxSize *arg2 = 0 ;
50668 void *argp1 = 0 ;
50669 int res1 = 0 ;
50670 wxSize temp2 ;
50671 PyObject * obj0 = 0 ;
50672 PyObject * obj1 = 0 ;
50673 char * kwnames[] = {
50674 (char *) "self",(char *) "size", NULL
50675 };
50676
50677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50679 if (!SWIG_IsOK(res1)) {
50680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50681 }
50682 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50683 {
50684 arg2 = &temp2;
50685 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50686 }
50687 {
50688 PyThreadState* __tstate = wxPyBeginAllowThreads();
50689 (arg1)->SetRatio((wxSize const &)*arg2);
50690 wxPyEndAllowThreads(__tstate);
50691 if (PyErr_Occurred()) SWIG_fail;
50692 }
50693 resultobj = SWIG_Py_Void();
50694 return resultobj;
50695 fail:
50696 return NULL;
50697 }
50698
50699
50700 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50701 PyObject *resultobj = 0;
50702 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50703 float arg2 ;
50704 void *argp1 = 0 ;
50705 int res1 = 0 ;
50706 float val2 ;
50707 int ecode2 = 0 ;
50708 PyObject * obj0 = 0 ;
50709 PyObject * obj1 = 0 ;
50710 char * kwnames[] = {
50711 (char *) "self",(char *) "ratio", NULL
50712 };
50713
50714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50716 if (!SWIG_IsOK(res1)) {
50717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50718 }
50719 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50720 ecode2 = SWIG_AsVal_float(obj1, &val2);
50721 if (!SWIG_IsOK(ecode2)) {
50722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50723 }
50724 arg2 = static_cast< float >(val2);
50725 {
50726 PyThreadState* __tstate = wxPyBeginAllowThreads();
50727 (arg1)->SetRatio(arg2);
50728 wxPyEndAllowThreads(__tstate);
50729 if (PyErr_Occurred()) SWIG_fail;
50730 }
50731 resultobj = SWIG_Py_Void();
50732 return resultobj;
50733 fail:
50734 return NULL;
50735 }
50736
50737
50738 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50739 PyObject *resultobj = 0;
50740 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50741 float result;
50742 void *argp1 = 0 ;
50743 int res1 = 0 ;
50744 PyObject *swig_obj[1] ;
50745
50746 if (!args) SWIG_fail;
50747 swig_obj[0] = args;
50748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50749 if (!SWIG_IsOK(res1)) {
50750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50751 }
50752 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50753 {
50754 PyThreadState* __tstate = wxPyBeginAllowThreads();
50755 result = (float)(arg1)->GetRatio();
50756 wxPyEndAllowThreads(__tstate);
50757 if (PyErr_Occurred()) SWIG_fail;
50758 }
50759 resultobj = SWIG_From_float(static_cast< float >(result));
50760 return resultobj;
50761 fail:
50762 return NULL;
50763 }
50764
50765
50766 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50767 PyObject *resultobj = 0;
50768 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50769 wxRect result;
50770 void *argp1 = 0 ;
50771 int res1 = 0 ;
50772 PyObject *swig_obj[1] ;
50773
50774 if (!args) SWIG_fail;
50775 swig_obj[0] = args;
50776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50777 if (!SWIG_IsOK(res1)) {
50778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50779 }
50780 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50781 {
50782 PyThreadState* __tstate = wxPyBeginAllowThreads();
50783 result = (arg1)->GetRect();
50784 wxPyEndAllowThreads(__tstate);
50785 if (PyErr_Occurred()) SWIG_fail;
50786 }
50787 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50788 return resultobj;
50789 fail:
50790 return NULL;
50791 }
50792
50793
50794 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50795 PyObject *resultobj = 0;
50796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50797 bool result;
50798 void *argp1 = 0 ;
50799 int res1 = 0 ;
50800 PyObject *swig_obj[1] ;
50801
50802 if (!args) SWIG_fail;
50803 swig_obj[0] = args;
50804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50805 if (!SWIG_IsOK(res1)) {
50806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50807 }
50808 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50809 {
50810 PyThreadState* __tstate = wxPyBeginAllowThreads();
50811 result = (bool)(arg1)->IsWindow();
50812 wxPyEndAllowThreads(__tstate);
50813 if (PyErr_Occurred()) SWIG_fail;
50814 }
50815 {
50816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50817 }
50818 return resultobj;
50819 fail:
50820 return NULL;
50821 }
50822
50823
50824 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50825 PyObject *resultobj = 0;
50826 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50827 bool result;
50828 void *argp1 = 0 ;
50829 int res1 = 0 ;
50830 PyObject *swig_obj[1] ;
50831
50832 if (!args) SWIG_fail;
50833 swig_obj[0] = args;
50834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50835 if (!SWIG_IsOK(res1)) {
50836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50837 }
50838 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50839 {
50840 PyThreadState* __tstate = wxPyBeginAllowThreads();
50841 result = (bool)(arg1)->IsSizer();
50842 wxPyEndAllowThreads(__tstate);
50843 if (PyErr_Occurred()) SWIG_fail;
50844 }
50845 {
50846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50847 }
50848 return resultobj;
50849 fail:
50850 return NULL;
50851 }
50852
50853
50854 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50855 PyObject *resultobj = 0;
50856 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50857 bool result;
50858 void *argp1 = 0 ;
50859 int res1 = 0 ;
50860 PyObject *swig_obj[1] ;
50861
50862 if (!args) SWIG_fail;
50863 swig_obj[0] = args;
50864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50865 if (!SWIG_IsOK(res1)) {
50866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50867 }
50868 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50869 {
50870 PyThreadState* __tstate = wxPyBeginAllowThreads();
50871 result = (bool)(arg1)->IsSpacer();
50872 wxPyEndAllowThreads(__tstate);
50873 if (PyErr_Occurred()) SWIG_fail;
50874 }
50875 {
50876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50877 }
50878 return resultobj;
50879 fail:
50880 return NULL;
50881 }
50882
50883
50884 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50885 PyObject *resultobj = 0;
50886 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50887 int arg2 ;
50888 void *argp1 = 0 ;
50889 int res1 = 0 ;
50890 int val2 ;
50891 int ecode2 = 0 ;
50892 PyObject * obj0 = 0 ;
50893 PyObject * obj1 = 0 ;
50894 char * kwnames[] = {
50895 (char *) "self",(char *) "proportion", NULL
50896 };
50897
50898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50900 if (!SWIG_IsOK(res1)) {
50901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50902 }
50903 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50904 ecode2 = SWIG_AsVal_int(obj1, &val2);
50905 if (!SWIG_IsOK(ecode2)) {
50906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50907 }
50908 arg2 = static_cast< int >(val2);
50909 {
50910 PyThreadState* __tstate = wxPyBeginAllowThreads();
50911 (arg1)->SetProportion(arg2);
50912 wxPyEndAllowThreads(__tstate);
50913 if (PyErr_Occurred()) SWIG_fail;
50914 }
50915 resultobj = SWIG_Py_Void();
50916 return resultobj;
50917 fail:
50918 return NULL;
50919 }
50920
50921
50922 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50923 PyObject *resultobj = 0;
50924 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50925 int result;
50926 void *argp1 = 0 ;
50927 int res1 = 0 ;
50928 PyObject *swig_obj[1] ;
50929
50930 if (!args) SWIG_fail;
50931 swig_obj[0] = args;
50932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50933 if (!SWIG_IsOK(res1)) {
50934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50935 }
50936 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 result = (int)(arg1)->GetProportion();
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 resultobj = SWIG_From_int(static_cast< int >(result));
50944 return resultobj;
50945 fail:
50946 return NULL;
50947 }
50948
50949
50950 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50951 PyObject *resultobj = 0;
50952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50953 int arg2 ;
50954 void *argp1 = 0 ;
50955 int res1 = 0 ;
50956 int val2 ;
50957 int ecode2 = 0 ;
50958 PyObject * obj0 = 0 ;
50959 PyObject * obj1 = 0 ;
50960 char * kwnames[] = {
50961 (char *) "self",(char *) "flag", NULL
50962 };
50963
50964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50966 if (!SWIG_IsOK(res1)) {
50967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50968 }
50969 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50970 ecode2 = SWIG_AsVal_int(obj1, &val2);
50971 if (!SWIG_IsOK(ecode2)) {
50972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50973 }
50974 arg2 = static_cast< int >(val2);
50975 {
50976 PyThreadState* __tstate = wxPyBeginAllowThreads();
50977 (arg1)->SetFlag(arg2);
50978 wxPyEndAllowThreads(__tstate);
50979 if (PyErr_Occurred()) SWIG_fail;
50980 }
50981 resultobj = SWIG_Py_Void();
50982 return resultobj;
50983 fail:
50984 return NULL;
50985 }
50986
50987
50988 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50989 PyObject *resultobj = 0;
50990 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50991 int result;
50992 void *argp1 = 0 ;
50993 int res1 = 0 ;
50994 PyObject *swig_obj[1] ;
50995
50996 if (!args) SWIG_fail;
50997 swig_obj[0] = args;
50998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50999 if (!SWIG_IsOK(res1)) {
51000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51001 }
51002 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51003 {
51004 PyThreadState* __tstate = wxPyBeginAllowThreads();
51005 result = (int)(arg1)->GetFlag();
51006 wxPyEndAllowThreads(__tstate);
51007 if (PyErr_Occurred()) SWIG_fail;
51008 }
51009 resultobj = SWIG_From_int(static_cast< int >(result));
51010 return resultobj;
51011 fail:
51012 return NULL;
51013 }
51014
51015
51016 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51017 PyObject *resultobj = 0;
51018 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51019 int arg2 ;
51020 void *argp1 = 0 ;
51021 int res1 = 0 ;
51022 int val2 ;
51023 int ecode2 = 0 ;
51024 PyObject * obj0 = 0 ;
51025 PyObject * obj1 = 0 ;
51026 char * kwnames[] = {
51027 (char *) "self",(char *) "border", NULL
51028 };
51029
51030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
51031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51032 if (!SWIG_IsOK(res1)) {
51033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51034 }
51035 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51036 ecode2 = SWIG_AsVal_int(obj1, &val2);
51037 if (!SWIG_IsOK(ecode2)) {
51038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
51039 }
51040 arg2 = static_cast< int >(val2);
51041 {
51042 PyThreadState* __tstate = wxPyBeginAllowThreads();
51043 (arg1)->SetBorder(arg2);
51044 wxPyEndAllowThreads(__tstate);
51045 if (PyErr_Occurred()) SWIG_fail;
51046 }
51047 resultobj = SWIG_Py_Void();
51048 return resultobj;
51049 fail:
51050 return NULL;
51051 }
51052
51053
51054 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51055 PyObject *resultobj = 0;
51056 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51057 int result;
51058 void *argp1 = 0 ;
51059 int res1 = 0 ;
51060 PyObject *swig_obj[1] ;
51061
51062 if (!args) SWIG_fail;
51063 swig_obj[0] = args;
51064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51065 if (!SWIG_IsOK(res1)) {
51066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51067 }
51068 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51069 {
51070 PyThreadState* __tstate = wxPyBeginAllowThreads();
51071 result = (int)(arg1)->GetBorder();
51072 wxPyEndAllowThreads(__tstate);
51073 if (PyErr_Occurred()) SWIG_fail;
51074 }
51075 resultobj = SWIG_From_int(static_cast< int >(result));
51076 return resultobj;
51077 fail:
51078 return NULL;
51079 }
51080
51081
51082 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51083 PyObject *resultobj = 0;
51084 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51085 wxWindow *result = 0 ;
51086 void *argp1 = 0 ;
51087 int res1 = 0 ;
51088 PyObject *swig_obj[1] ;
51089
51090 if (!args) SWIG_fail;
51091 swig_obj[0] = args;
51092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51093 if (!SWIG_IsOK(res1)) {
51094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51095 }
51096 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51097 {
51098 PyThreadState* __tstate = wxPyBeginAllowThreads();
51099 result = (wxWindow *)(arg1)->GetWindow();
51100 wxPyEndAllowThreads(__tstate);
51101 if (PyErr_Occurred()) SWIG_fail;
51102 }
51103 {
51104 resultobj = wxPyMake_wxObject(result, 0);
51105 }
51106 return resultobj;
51107 fail:
51108 return NULL;
51109 }
51110
51111
51112 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51113 PyObject *resultobj = 0;
51114 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51115 wxSizer *result = 0 ;
51116 void *argp1 = 0 ;
51117 int res1 = 0 ;
51118 PyObject *swig_obj[1] ;
51119
51120 if (!args) SWIG_fail;
51121 swig_obj[0] = args;
51122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51123 if (!SWIG_IsOK(res1)) {
51124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51125 }
51126 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51127 {
51128 PyThreadState* __tstate = wxPyBeginAllowThreads();
51129 result = (wxSizer *)(arg1)->GetSizer();
51130 wxPyEndAllowThreads(__tstate);
51131 if (PyErr_Occurred()) SWIG_fail;
51132 }
51133 {
51134 resultobj = wxPyMake_wxObject(result, (bool)0);
51135 }
51136 return resultobj;
51137 fail:
51138 return NULL;
51139 }
51140
51141
51142 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51143 PyObject *resultobj = 0;
51144 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51145 wxSize result;
51146 void *argp1 = 0 ;
51147 int res1 = 0 ;
51148 PyObject *swig_obj[1] ;
51149
51150 if (!args) SWIG_fail;
51151 swig_obj[0] = args;
51152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51153 if (!SWIG_IsOK(res1)) {
51154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51155 }
51156 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51157 {
51158 PyThreadState* __tstate = wxPyBeginAllowThreads();
51159 result = (arg1)->GetSpacer();
51160 wxPyEndAllowThreads(__tstate);
51161 if (PyErr_Occurred()) SWIG_fail;
51162 }
51163 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51164 return resultobj;
51165 fail:
51166 return NULL;
51167 }
51168
51169
51170 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51171 PyObject *resultobj = 0;
51172 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51173 wxWindow *arg2 = (wxWindow *) 0 ;
51174 void *argp1 = 0 ;
51175 int res1 = 0 ;
51176 void *argp2 = 0 ;
51177 int res2 = 0 ;
51178 PyObject * obj0 = 0 ;
51179 PyObject * obj1 = 0 ;
51180 char * kwnames[] = {
51181 (char *) "self",(char *) "window", NULL
51182 };
51183
51184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51186 if (!SWIG_IsOK(res1)) {
51187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51188 }
51189 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51191 if (!SWIG_IsOK(res2)) {
51192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51193 }
51194 arg2 = reinterpret_cast< wxWindow * >(argp2);
51195 {
51196 PyThreadState* __tstate = wxPyBeginAllowThreads();
51197 (arg1)->SetWindow(arg2);
51198 wxPyEndAllowThreads(__tstate);
51199 if (PyErr_Occurred()) SWIG_fail;
51200 }
51201 resultobj = SWIG_Py_Void();
51202 return resultobj;
51203 fail:
51204 return NULL;
51205 }
51206
51207
51208 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51209 PyObject *resultobj = 0;
51210 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51211 wxSizer *arg2 = (wxSizer *) 0 ;
51212 void *argp1 = 0 ;
51213 int res1 = 0 ;
51214 int res2 = 0 ;
51215 PyObject * obj0 = 0 ;
51216 PyObject * obj1 = 0 ;
51217 char * kwnames[] = {
51218 (char *) "self",(char *) "sizer", NULL
51219 };
51220
51221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51223 if (!SWIG_IsOK(res1)) {
51224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51225 }
51226 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51227 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51228 if (!SWIG_IsOK(res2)) {
51229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51230 }
51231 {
51232 PyThreadState* __tstate = wxPyBeginAllowThreads();
51233 (arg1)->SetSizer(arg2);
51234 wxPyEndAllowThreads(__tstate);
51235 if (PyErr_Occurred()) SWIG_fail;
51236 }
51237 resultobj = SWIG_Py_Void();
51238 return resultobj;
51239 fail:
51240 return NULL;
51241 }
51242
51243
51244 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51245 PyObject *resultobj = 0;
51246 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51247 wxSize *arg2 = 0 ;
51248 void *argp1 = 0 ;
51249 int res1 = 0 ;
51250 wxSize temp2 ;
51251 PyObject * obj0 = 0 ;
51252 PyObject * obj1 = 0 ;
51253 char * kwnames[] = {
51254 (char *) "self",(char *) "size", NULL
51255 };
51256
51257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51259 if (!SWIG_IsOK(res1)) {
51260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51261 }
51262 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51263 {
51264 arg2 = &temp2;
51265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51266 }
51267 {
51268 PyThreadState* __tstate = wxPyBeginAllowThreads();
51269 (arg1)->SetSpacer((wxSize const &)*arg2);
51270 wxPyEndAllowThreads(__tstate);
51271 if (PyErr_Occurred()) SWIG_fail;
51272 }
51273 resultobj = SWIG_Py_Void();
51274 return resultobj;
51275 fail:
51276 return NULL;
51277 }
51278
51279
51280 SWIGINTERN PyObject *_wrap_SizerItem_AssignWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51281 PyObject *resultobj = 0;
51282 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51283 wxWindow *arg2 = (wxWindow *) 0 ;
51284 void *argp1 = 0 ;
51285 int res1 = 0 ;
51286 void *argp2 = 0 ;
51287 int res2 = 0 ;
51288 PyObject * obj0 = 0 ;
51289 PyObject * obj1 = 0 ;
51290 char * kwnames[] = {
51291 (char *) "self",(char *) "window", NULL
51292 };
51293
51294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51296 if (!SWIG_IsOK(res1)) {
51297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51298 }
51299 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51300 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51301 if (!SWIG_IsOK(res2)) {
51302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51303 }
51304 arg2 = reinterpret_cast< wxWindow * >(argp2);
51305 {
51306 PyThreadState* __tstate = wxPyBeginAllowThreads();
51307 (arg1)->AssignWindow(arg2);
51308 wxPyEndAllowThreads(__tstate);
51309 if (PyErr_Occurred()) SWIG_fail;
51310 }
51311 resultobj = SWIG_Py_Void();
51312 return resultobj;
51313 fail:
51314 return NULL;
51315 }
51316
51317
51318 SWIGINTERN PyObject *_wrap_SizerItem_AssignSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51319 PyObject *resultobj = 0;
51320 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51321 wxSizer *arg2 = (wxSizer *) 0 ;
51322 void *argp1 = 0 ;
51323 int res1 = 0 ;
51324 void *argp2 = 0 ;
51325 int res2 = 0 ;
51326 PyObject * obj0 = 0 ;
51327 PyObject * obj1 = 0 ;
51328 char * kwnames[] = {
51329 (char *) "self",(char *) "sizer", NULL
51330 };
51331
51332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51334 if (!SWIG_IsOK(res1)) {
51335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51336 }
51337 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51339 if (!SWIG_IsOK(res2)) {
51340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51341 }
51342 arg2 = reinterpret_cast< wxSizer * >(argp2);
51343 {
51344 PyThreadState* __tstate = wxPyBeginAllowThreads();
51345 (arg1)->AssignSizer(arg2);
51346 wxPyEndAllowThreads(__tstate);
51347 if (PyErr_Occurred()) SWIG_fail;
51348 }
51349 resultobj = SWIG_Py_Void();
51350 return resultobj;
51351 fail:
51352 return NULL;
51353 }
51354
51355
51356 SWIGINTERN PyObject *_wrap_SizerItem_AssignSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51357 PyObject *resultobj = 0;
51358 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51359 wxSize *arg2 = 0 ;
51360 void *argp1 = 0 ;
51361 int res1 = 0 ;
51362 wxSize temp2 ;
51363 PyObject * obj0 = 0 ;
51364 PyObject * obj1 = 0 ;
51365 char * kwnames[] = {
51366 (char *) "self",(char *) "size", NULL
51367 };
51368
51369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51371 if (!SWIG_IsOK(res1)) {
51372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51373 }
51374 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51375 {
51376 arg2 = &temp2;
51377 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51378 }
51379 {
51380 PyThreadState* __tstate = wxPyBeginAllowThreads();
51381 (arg1)->AssignSpacer((wxSize const &)*arg2);
51382 wxPyEndAllowThreads(__tstate);
51383 if (PyErr_Occurred()) SWIG_fail;
51384 }
51385 resultobj = SWIG_Py_Void();
51386 return resultobj;
51387 fail:
51388 return NULL;
51389 }
51390
51391
51392 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51393 PyObject *resultobj = 0;
51394 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51395 bool arg2 ;
51396 void *argp1 = 0 ;
51397 int res1 = 0 ;
51398 bool val2 ;
51399 int ecode2 = 0 ;
51400 PyObject * obj0 = 0 ;
51401 PyObject * obj1 = 0 ;
51402 char * kwnames[] = {
51403 (char *) "self",(char *) "show", NULL
51404 };
51405
51406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
51407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51408 if (!SWIG_IsOK(res1)) {
51409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51410 }
51411 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51412 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51413 if (!SWIG_IsOK(ecode2)) {
51414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
51415 }
51416 arg2 = static_cast< bool >(val2);
51417 {
51418 PyThreadState* __tstate = wxPyBeginAllowThreads();
51419 (arg1)->Show(arg2);
51420 wxPyEndAllowThreads(__tstate);
51421 if (PyErr_Occurred()) SWIG_fail;
51422 }
51423 resultobj = SWIG_Py_Void();
51424 return resultobj;
51425 fail:
51426 return NULL;
51427 }
51428
51429
51430 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51431 PyObject *resultobj = 0;
51432 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51433 bool result;
51434 void *argp1 = 0 ;
51435 int res1 = 0 ;
51436 PyObject *swig_obj[1] ;
51437
51438 if (!args) SWIG_fail;
51439 swig_obj[0] = args;
51440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51441 if (!SWIG_IsOK(res1)) {
51442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51443 }
51444 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51445 {
51446 PyThreadState* __tstate = wxPyBeginAllowThreads();
51447 result = (bool)(arg1)->IsShown();
51448 wxPyEndAllowThreads(__tstate);
51449 if (PyErr_Occurred()) SWIG_fail;
51450 }
51451 {
51452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51453 }
51454 return resultobj;
51455 fail:
51456 return NULL;
51457 }
51458
51459
51460 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51461 PyObject *resultobj = 0;
51462 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51463 wxPoint result;
51464 void *argp1 = 0 ;
51465 int res1 = 0 ;
51466 PyObject *swig_obj[1] ;
51467
51468 if (!args) SWIG_fail;
51469 swig_obj[0] = args;
51470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51471 if (!SWIG_IsOK(res1)) {
51472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51473 }
51474 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51475 {
51476 PyThreadState* __tstate = wxPyBeginAllowThreads();
51477 result = (arg1)->GetPosition();
51478 wxPyEndAllowThreads(__tstate);
51479 if (PyErr_Occurred()) SWIG_fail;
51480 }
51481 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
51482 return resultobj;
51483 fail:
51484 return NULL;
51485 }
51486
51487
51488 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51489 PyObject *resultobj = 0;
51490 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51491 PyObject *result = 0 ;
51492 void *argp1 = 0 ;
51493 int res1 = 0 ;
51494 PyObject *swig_obj[1] ;
51495
51496 if (!args) SWIG_fail;
51497 swig_obj[0] = args;
51498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51499 if (!SWIG_IsOK(res1)) {
51500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51501 }
51502 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51503 {
51504 PyThreadState* __tstate = wxPyBeginAllowThreads();
51505 result = (PyObject *)wxSizerItem_GetUserData(arg1);
51506 wxPyEndAllowThreads(__tstate);
51507 if (PyErr_Occurred()) SWIG_fail;
51508 }
51509 resultobj = result;
51510 return resultobj;
51511 fail:
51512 return NULL;
51513 }
51514
51515
51516 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51517 PyObject *resultobj = 0;
51518 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51519 PyObject *arg2 = (PyObject *) 0 ;
51520 void *argp1 = 0 ;
51521 int res1 = 0 ;
51522 PyObject * obj0 = 0 ;
51523 PyObject * obj1 = 0 ;
51524 char * kwnames[] = {
51525 (char *) "self",(char *) "userData", NULL
51526 };
51527
51528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
51529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51530 if (!SWIG_IsOK(res1)) {
51531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51532 }
51533 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51534 arg2 = obj1;
51535 {
51536 PyThreadState* __tstate = wxPyBeginAllowThreads();
51537 wxSizerItem_SetUserData(arg1,arg2);
51538 wxPyEndAllowThreads(__tstate);
51539 if (PyErr_Occurred()) SWIG_fail;
51540 }
51541 resultobj = SWIG_Py_Void();
51542 return resultobj;
51543 fail:
51544 return NULL;
51545 }
51546
51547
51548 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51549 PyObject *obj;
51550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51551 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
51552 return SWIG_Py_Void();
51553 }
51554
51555 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51556 return SWIG_Python_InitShadowInstance(args);
51557 }
51558
51559 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51560 PyObject *resultobj = 0;
51561 wxSizer *arg1 = (wxSizer *) 0 ;
51562 void *argp1 = 0 ;
51563 int res1 = 0 ;
51564 PyObject *swig_obj[1] ;
51565
51566 if (!args) SWIG_fail;
51567 swig_obj[0] = args;
51568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51569 if (!SWIG_IsOK(res1)) {
51570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51571 }
51572 arg1 = reinterpret_cast< wxSizer * >(argp1);
51573 {
51574 PyThreadState* __tstate = wxPyBeginAllowThreads();
51575 delete arg1;
51576
51577 wxPyEndAllowThreads(__tstate);
51578 if (PyErr_Occurred()) SWIG_fail;
51579 }
51580 resultobj = SWIG_Py_Void();
51581 return resultobj;
51582 fail:
51583 return NULL;
51584 }
51585
51586
51587 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51588 PyObject *resultobj = 0;
51589 wxSizer *arg1 = (wxSizer *) 0 ;
51590 PyObject *arg2 = (PyObject *) 0 ;
51591 void *argp1 = 0 ;
51592 int res1 = 0 ;
51593 PyObject * obj0 = 0 ;
51594 PyObject * obj1 = 0 ;
51595 char * kwnames[] = {
51596 (char *) "self",(char *) "_self", NULL
51597 };
51598
51599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
51600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51601 if (!SWIG_IsOK(res1)) {
51602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
51603 }
51604 arg1 = reinterpret_cast< wxSizer * >(argp1);
51605 arg2 = obj1;
51606 {
51607 PyThreadState* __tstate = wxPyBeginAllowThreads();
51608 wxSizer__setOORInfo(arg1,arg2);
51609 wxPyEndAllowThreads(__tstate);
51610 if (PyErr_Occurred()) SWIG_fail;
51611 }
51612 resultobj = SWIG_Py_Void();
51613 return resultobj;
51614 fail:
51615 return NULL;
51616 }
51617
51618
51619 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51620 PyObject *resultobj = 0;
51621 wxSizer *arg1 = (wxSizer *) 0 ;
51622 PyObject *arg2 = (PyObject *) 0 ;
51623 int arg3 = (int) 0 ;
51624 int arg4 = (int) 0 ;
51625 int arg5 = (int) 0 ;
51626 PyObject *arg6 = (PyObject *) NULL ;
51627 wxSizerItem *result = 0 ;
51628 void *argp1 = 0 ;
51629 int res1 = 0 ;
51630 int val3 ;
51631 int ecode3 = 0 ;
51632 int val4 ;
51633 int ecode4 = 0 ;
51634 int val5 ;
51635 int ecode5 = 0 ;
51636 PyObject * obj0 = 0 ;
51637 PyObject * obj1 = 0 ;
51638 PyObject * obj2 = 0 ;
51639 PyObject * obj3 = 0 ;
51640 PyObject * obj4 = 0 ;
51641 PyObject * obj5 = 0 ;
51642 char * kwnames[] = {
51643 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51644 };
51645
51646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51648 if (!SWIG_IsOK(res1)) {
51649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
51650 }
51651 arg1 = reinterpret_cast< wxSizer * >(argp1);
51652 arg2 = obj1;
51653 if (obj2) {
51654 ecode3 = SWIG_AsVal_int(obj2, &val3);
51655 if (!SWIG_IsOK(ecode3)) {
51656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
51657 }
51658 arg3 = static_cast< int >(val3);
51659 }
51660 if (obj3) {
51661 ecode4 = SWIG_AsVal_int(obj3, &val4);
51662 if (!SWIG_IsOK(ecode4)) {
51663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
51664 }
51665 arg4 = static_cast< int >(val4);
51666 }
51667 if (obj4) {
51668 ecode5 = SWIG_AsVal_int(obj4, &val5);
51669 if (!SWIG_IsOK(ecode5)) {
51670 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
51671 }
51672 arg5 = static_cast< int >(val5);
51673 }
51674 if (obj5) {
51675 arg6 = obj5;
51676 }
51677 {
51678 PyThreadState* __tstate = wxPyBeginAllowThreads();
51679 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
51680 wxPyEndAllowThreads(__tstate);
51681 if (PyErr_Occurred()) SWIG_fail;
51682 }
51683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51684 return resultobj;
51685 fail:
51686 return NULL;
51687 }
51688
51689
51690 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51691 PyObject *resultobj = 0;
51692 wxSizer *arg1 = (wxSizer *) 0 ;
51693 PyObject *arg2 = (PyObject *) 0 ;
51694 wxSizerFlags *arg3 = 0 ;
51695 wxSizerItem *result = 0 ;
51696 void *argp1 = 0 ;
51697 int res1 = 0 ;
51698 void *argp3 = 0 ;
51699 int res3 = 0 ;
51700 PyObject * obj0 = 0 ;
51701 PyObject * obj1 = 0 ;
51702 PyObject * obj2 = 0 ;
51703 char * kwnames[] = {
51704 (char *) "self",(char *) "item",(char *) "flags", NULL
51705 };
51706
51707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51709 if (!SWIG_IsOK(res1)) {
51710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51711 }
51712 arg1 = reinterpret_cast< wxSizer * >(argp1);
51713 arg2 = obj1;
51714 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51715 if (!SWIG_IsOK(res3)) {
51716 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51717 }
51718 if (!argp3) {
51719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51720 }
51721 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51722 {
51723 PyThreadState* __tstate = wxPyBeginAllowThreads();
51724 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51725 wxPyEndAllowThreads(__tstate);
51726 if (PyErr_Occurred()) SWIG_fail;
51727 }
51728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51729 return resultobj;
51730 fail:
51731 return NULL;
51732 }
51733
51734
51735 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51736 PyObject *resultobj = 0;
51737 wxSizer *arg1 = (wxSizer *) 0 ;
51738 int arg2 ;
51739 PyObject *arg3 = (PyObject *) 0 ;
51740 int arg4 = (int) 0 ;
51741 int arg5 = (int) 0 ;
51742 int arg6 = (int) 0 ;
51743 PyObject *arg7 = (PyObject *) NULL ;
51744 wxSizerItem *result = 0 ;
51745 void *argp1 = 0 ;
51746 int res1 = 0 ;
51747 int val2 ;
51748 int ecode2 = 0 ;
51749 int val4 ;
51750 int ecode4 = 0 ;
51751 int val5 ;
51752 int ecode5 = 0 ;
51753 int val6 ;
51754 int ecode6 = 0 ;
51755 PyObject * obj0 = 0 ;
51756 PyObject * obj1 = 0 ;
51757 PyObject * obj2 = 0 ;
51758 PyObject * obj3 = 0 ;
51759 PyObject * obj4 = 0 ;
51760 PyObject * obj5 = 0 ;
51761 PyObject * obj6 = 0 ;
51762 char * kwnames[] = {
51763 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51764 };
51765
51766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51768 if (!SWIG_IsOK(res1)) {
51769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51770 }
51771 arg1 = reinterpret_cast< wxSizer * >(argp1);
51772 ecode2 = SWIG_AsVal_int(obj1, &val2);
51773 if (!SWIG_IsOK(ecode2)) {
51774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51775 }
51776 arg2 = static_cast< int >(val2);
51777 arg3 = obj2;
51778 if (obj3) {
51779 ecode4 = SWIG_AsVal_int(obj3, &val4);
51780 if (!SWIG_IsOK(ecode4)) {
51781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51782 }
51783 arg4 = static_cast< int >(val4);
51784 }
51785 if (obj4) {
51786 ecode5 = SWIG_AsVal_int(obj4, &val5);
51787 if (!SWIG_IsOK(ecode5)) {
51788 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51789 }
51790 arg5 = static_cast< int >(val5);
51791 }
51792 if (obj5) {
51793 ecode6 = SWIG_AsVal_int(obj5, &val6);
51794 if (!SWIG_IsOK(ecode6)) {
51795 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51796 }
51797 arg6 = static_cast< int >(val6);
51798 }
51799 if (obj6) {
51800 arg7 = obj6;
51801 }
51802 {
51803 PyThreadState* __tstate = wxPyBeginAllowThreads();
51804 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51805 wxPyEndAllowThreads(__tstate);
51806 if (PyErr_Occurred()) SWIG_fail;
51807 }
51808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51809 return resultobj;
51810 fail:
51811 return NULL;
51812 }
51813
51814
51815 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51816 PyObject *resultobj = 0;
51817 wxSizer *arg1 = (wxSizer *) 0 ;
51818 int arg2 ;
51819 PyObject *arg3 = (PyObject *) 0 ;
51820 wxSizerFlags *arg4 = 0 ;
51821 wxSizerItem *result = 0 ;
51822 void *argp1 = 0 ;
51823 int res1 = 0 ;
51824 int val2 ;
51825 int ecode2 = 0 ;
51826 void *argp4 = 0 ;
51827 int res4 = 0 ;
51828 PyObject * obj0 = 0 ;
51829 PyObject * obj1 = 0 ;
51830 PyObject * obj2 = 0 ;
51831 PyObject * obj3 = 0 ;
51832 char * kwnames[] = {
51833 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51834 };
51835
51836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51838 if (!SWIG_IsOK(res1)) {
51839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51840 }
51841 arg1 = reinterpret_cast< wxSizer * >(argp1);
51842 ecode2 = SWIG_AsVal_int(obj1, &val2);
51843 if (!SWIG_IsOK(ecode2)) {
51844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51845 }
51846 arg2 = static_cast< int >(val2);
51847 arg3 = obj2;
51848 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51849 if (!SWIG_IsOK(res4)) {
51850 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51851 }
51852 if (!argp4) {
51853 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51854 }
51855 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51856 {
51857 PyThreadState* __tstate = wxPyBeginAllowThreads();
51858 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51859 wxPyEndAllowThreads(__tstate);
51860 if (PyErr_Occurred()) SWIG_fail;
51861 }
51862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51863 return resultobj;
51864 fail:
51865 return NULL;
51866 }
51867
51868
51869 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51870 PyObject *resultobj = 0;
51871 wxSizer *arg1 = (wxSizer *) 0 ;
51872 PyObject *arg2 = (PyObject *) 0 ;
51873 int arg3 = (int) 0 ;
51874 int arg4 = (int) 0 ;
51875 int arg5 = (int) 0 ;
51876 PyObject *arg6 = (PyObject *) NULL ;
51877 wxSizerItem *result = 0 ;
51878 void *argp1 = 0 ;
51879 int res1 = 0 ;
51880 int val3 ;
51881 int ecode3 = 0 ;
51882 int val4 ;
51883 int ecode4 = 0 ;
51884 int val5 ;
51885 int ecode5 = 0 ;
51886 PyObject * obj0 = 0 ;
51887 PyObject * obj1 = 0 ;
51888 PyObject * obj2 = 0 ;
51889 PyObject * obj3 = 0 ;
51890 PyObject * obj4 = 0 ;
51891 PyObject * obj5 = 0 ;
51892 char * kwnames[] = {
51893 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51894 };
51895
51896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51898 if (!SWIG_IsOK(res1)) {
51899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51900 }
51901 arg1 = reinterpret_cast< wxSizer * >(argp1);
51902 arg2 = obj1;
51903 if (obj2) {
51904 ecode3 = SWIG_AsVal_int(obj2, &val3);
51905 if (!SWIG_IsOK(ecode3)) {
51906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51907 }
51908 arg3 = static_cast< int >(val3);
51909 }
51910 if (obj3) {
51911 ecode4 = SWIG_AsVal_int(obj3, &val4);
51912 if (!SWIG_IsOK(ecode4)) {
51913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51914 }
51915 arg4 = static_cast< int >(val4);
51916 }
51917 if (obj4) {
51918 ecode5 = SWIG_AsVal_int(obj4, &val5);
51919 if (!SWIG_IsOK(ecode5)) {
51920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51921 }
51922 arg5 = static_cast< int >(val5);
51923 }
51924 if (obj5) {
51925 arg6 = obj5;
51926 }
51927 {
51928 PyThreadState* __tstate = wxPyBeginAllowThreads();
51929 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51930 wxPyEndAllowThreads(__tstate);
51931 if (PyErr_Occurred()) SWIG_fail;
51932 }
51933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51934 return resultobj;
51935 fail:
51936 return NULL;
51937 }
51938
51939
51940 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51941 PyObject *resultobj = 0;
51942 wxSizer *arg1 = (wxSizer *) 0 ;
51943 PyObject *arg2 = (PyObject *) 0 ;
51944 wxSizerFlags *arg3 = 0 ;
51945 wxSizerItem *result = 0 ;
51946 void *argp1 = 0 ;
51947 int res1 = 0 ;
51948 void *argp3 = 0 ;
51949 int res3 = 0 ;
51950 PyObject * obj0 = 0 ;
51951 PyObject * obj1 = 0 ;
51952 PyObject * obj2 = 0 ;
51953 char * kwnames[] = {
51954 (char *) "self",(char *) "item",(char *) "flags", NULL
51955 };
51956
51957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51959 if (!SWIG_IsOK(res1)) {
51960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51961 }
51962 arg1 = reinterpret_cast< wxSizer * >(argp1);
51963 arg2 = obj1;
51964 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51965 if (!SWIG_IsOK(res3)) {
51966 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51967 }
51968 if (!argp3) {
51969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51970 }
51971 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51972 {
51973 PyThreadState* __tstate = wxPyBeginAllowThreads();
51974 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51975 wxPyEndAllowThreads(__tstate);
51976 if (PyErr_Occurred()) SWIG_fail;
51977 }
51978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51979 return resultobj;
51980 fail:
51981 return NULL;
51982 }
51983
51984
51985 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51986 PyObject *resultobj = 0;
51987 wxSizer *arg1 = (wxSizer *) 0 ;
51988 PyObject *arg2 = (PyObject *) 0 ;
51989 bool result;
51990 void *argp1 = 0 ;
51991 int res1 = 0 ;
51992 PyObject * obj0 = 0 ;
51993 PyObject * obj1 = 0 ;
51994 char * kwnames[] = {
51995 (char *) "self",(char *) "item", NULL
51996 };
51997
51998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52000 if (!SWIG_IsOK(res1)) {
52001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
52002 }
52003 arg1 = reinterpret_cast< wxSizer * >(argp1);
52004 arg2 = obj1;
52005 {
52006 PyThreadState* __tstate = wxPyBeginAllowThreads();
52007 result = (bool)wxSizer_Remove(arg1,arg2);
52008 wxPyEndAllowThreads(__tstate);
52009 if (PyErr_Occurred()) SWIG_fail;
52010 }
52011 {
52012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52013 }
52014 return resultobj;
52015 fail:
52016 return NULL;
52017 }
52018
52019
52020 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52021 PyObject *resultobj = 0;
52022 wxSizer *arg1 = (wxSizer *) 0 ;
52023 PyObject *arg2 = (PyObject *) 0 ;
52024 bool result;
52025 void *argp1 = 0 ;
52026 int res1 = 0 ;
52027 PyObject * obj0 = 0 ;
52028 PyObject * obj1 = 0 ;
52029 char * kwnames[] = {
52030 (char *) "self",(char *) "item", NULL
52031 };
52032
52033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
52034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52035 if (!SWIG_IsOK(res1)) {
52036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
52037 }
52038 arg1 = reinterpret_cast< wxSizer * >(argp1);
52039 arg2 = obj1;
52040 {
52041 PyThreadState* __tstate = wxPyBeginAllowThreads();
52042 result = (bool)wxSizer_Detach(arg1,arg2);
52043 wxPyEndAllowThreads(__tstate);
52044 if (PyErr_Occurred()) SWIG_fail;
52045 }
52046 {
52047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52048 }
52049 return resultobj;
52050 fail:
52051 return NULL;
52052 }
52053
52054
52055 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52056 PyObject *resultobj = 0;
52057 wxSizer *arg1 = (wxSizer *) 0 ;
52058 PyObject *arg2 = (PyObject *) 0 ;
52059 bool arg3 = (bool) false ;
52060 wxSizerItem *result = 0 ;
52061 void *argp1 = 0 ;
52062 int res1 = 0 ;
52063 bool val3 ;
52064 int ecode3 = 0 ;
52065 PyObject * obj0 = 0 ;
52066 PyObject * obj1 = 0 ;
52067 PyObject * obj2 = 0 ;
52068 char * kwnames[] = {
52069 (char *) "self",(char *) "item",(char *) "recursive", NULL
52070 };
52071
52072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52074 if (!SWIG_IsOK(res1)) {
52075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52076 }
52077 arg1 = reinterpret_cast< wxSizer * >(argp1);
52078 arg2 = obj1;
52079 if (obj2) {
52080 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52081 if (!SWIG_IsOK(ecode3)) {
52082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
52083 }
52084 arg3 = static_cast< bool >(val3);
52085 }
52086 {
52087 PyThreadState* __tstate = wxPyBeginAllowThreads();
52088 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
52089 wxPyEndAllowThreads(__tstate);
52090 if (PyErr_Occurred()) SWIG_fail;
52091 }
52092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52093 return resultobj;
52094 fail:
52095 return NULL;
52096 }
52097
52098
52099 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52100 PyObject *resultobj = 0;
52101 wxSizer *arg1 = (wxSizer *) 0 ;
52102 PyObject *arg2 = (PyObject *) 0 ;
52103 wxSize *arg3 = 0 ;
52104 void *argp1 = 0 ;
52105 int res1 = 0 ;
52106 wxSize temp3 ;
52107 PyObject * obj0 = 0 ;
52108 PyObject * obj1 = 0 ;
52109 PyObject * obj2 = 0 ;
52110 char * kwnames[] = {
52111 (char *) "self",(char *) "item",(char *) "size", NULL
52112 };
52113
52114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52116 if (!SWIG_IsOK(res1)) {
52117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52118 }
52119 arg1 = reinterpret_cast< wxSizer * >(argp1);
52120 arg2 = obj1;
52121 {
52122 arg3 = &temp3;
52123 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
52124 }
52125 {
52126 PyThreadState* __tstate = wxPyBeginAllowThreads();
52127 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
52128 wxPyEndAllowThreads(__tstate);
52129 if (PyErr_Occurred()) SWIG_fail;
52130 }
52131 resultobj = SWIG_Py_Void();
52132 return resultobj;
52133 fail:
52134 return NULL;
52135 }
52136
52137
52138 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52139 PyObject *resultobj = 0;
52140 wxSizer *arg1 = (wxSizer *) 0 ;
52141 wxWindow *arg2 = (wxWindow *) 0 ;
52142 wxWindow *arg3 = (wxWindow *) 0 ;
52143 bool arg4 = (bool) false ;
52144 bool result;
52145 void *argp1 = 0 ;
52146 int res1 = 0 ;
52147 void *argp2 = 0 ;
52148 int res2 = 0 ;
52149 void *argp3 = 0 ;
52150 int res3 = 0 ;
52151 bool val4 ;
52152 int ecode4 = 0 ;
52153 PyObject * obj0 = 0 ;
52154 PyObject * obj1 = 0 ;
52155 PyObject * obj2 = 0 ;
52156 PyObject * obj3 = 0 ;
52157 char * kwnames[] = {
52158 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
52159 };
52160
52161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52163 if (!SWIG_IsOK(res1)) {
52164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
52165 }
52166 arg1 = reinterpret_cast< wxSizer * >(argp1);
52167 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52168 if (!SWIG_IsOK(res2)) {
52169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52170 }
52171 arg2 = reinterpret_cast< wxWindow * >(argp2);
52172 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52173 if (!SWIG_IsOK(res3)) {
52174 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
52175 }
52176 arg3 = reinterpret_cast< wxWindow * >(argp3);
52177 if (obj3) {
52178 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52179 if (!SWIG_IsOK(ecode4)) {
52180 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
52181 }
52182 arg4 = static_cast< bool >(val4);
52183 }
52184 {
52185 PyThreadState* __tstate = wxPyBeginAllowThreads();
52186 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52187 wxPyEndAllowThreads(__tstate);
52188 if (PyErr_Occurred()) SWIG_fail;
52189 }
52190 {
52191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52192 }
52193 return resultobj;
52194 fail:
52195 return NULL;
52196 }
52197
52198
52199 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52200 PyObject *resultobj = 0;
52201 wxSizer *arg1 = (wxSizer *) 0 ;
52202 wxSizer *arg2 = (wxSizer *) 0 ;
52203 wxSizer *arg3 = (wxSizer *) 0 ;
52204 bool arg4 = (bool) false ;
52205 bool result;
52206 void *argp1 = 0 ;
52207 int res1 = 0 ;
52208 void *argp2 = 0 ;
52209 int res2 = 0 ;
52210 void *argp3 = 0 ;
52211 int res3 = 0 ;
52212 bool val4 ;
52213 int ecode4 = 0 ;
52214 PyObject * obj0 = 0 ;
52215 PyObject * obj1 = 0 ;
52216 PyObject * obj2 = 0 ;
52217 PyObject * obj3 = 0 ;
52218 char * kwnames[] = {
52219 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
52220 };
52221
52222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52224 if (!SWIG_IsOK(res1)) {
52225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
52226 }
52227 arg1 = reinterpret_cast< wxSizer * >(argp1);
52228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52229 if (!SWIG_IsOK(res2)) {
52230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
52231 }
52232 arg2 = reinterpret_cast< wxSizer * >(argp2);
52233 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
52234 if (!SWIG_IsOK(res3)) {
52235 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
52236 }
52237 arg3 = reinterpret_cast< wxSizer * >(argp3);
52238 if (obj3) {
52239 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52240 if (!SWIG_IsOK(ecode4)) {
52241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
52242 }
52243 arg4 = static_cast< bool >(val4);
52244 }
52245 {
52246 PyThreadState* __tstate = wxPyBeginAllowThreads();
52247 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52248 wxPyEndAllowThreads(__tstate);
52249 if (PyErr_Occurred()) SWIG_fail;
52250 }
52251 {
52252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52253 }
52254 return resultobj;
52255 fail:
52256 return NULL;
52257 }
52258
52259
52260 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52261 PyObject *resultobj = 0;
52262 wxSizer *arg1 = (wxSizer *) 0 ;
52263 size_t arg2 ;
52264 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52265 bool result;
52266 void *argp1 = 0 ;
52267 int res1 = 0 ;
52268 size_t val2 ;
52269 int ecode2 = 0 ;
52270 void *argp3 = 0 ;
52271 int res3 = 0 ;
52272 PyObject * obj0 = 0 ;
52273 PyObject * obj1 = 0 ;
52274 PyObject * obj2 = 0 ;
52275 char * kwnames[] = {
52276 (char *) "self",(char *) "index",(char *) "newitem", NULL
52277 };
52278
52279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52281 if (!SWIG_IsOK(res1)) {
52282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52283 }
52284 arg1 = reinterpret_cast< wxSizer * >(argp1);
52285 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52286 if (!SWIG_IsOK(ecode2)) {
52287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
52288 }
52289 arg2 = static_cast< size_t >(val2);
52290 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
52291 if (!SWIG_IsOK(res3)) {
52292 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52293 }
52294 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
52295 {
52296 PyThreadState* __tstate = wxPyBeginAllowThreads();
52297 result = (bool)(arg1)->Replace(arg2,arg3);
52298 wxPyEndAllowThreads(__tstate);
52299 if (PyErr_Occurred()) SWIG_fail;
52300 }
52301 {
52302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52303 }
52304 return resultobj;
52305 fail:
52306 return NULL;
52307 }
52308
52309
52310 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52311 PyObject *resultobj = 0;
52312 wxSizer *arg1 = (wxSizer *) 0 ;
52313 wxWindow *arg2 = (wxWindow *) 0 ;
52314 void *argp1 = 0 ;
52315 int res1 = 0 ;
52316 void *argp2 = 0 ;
52317 int res2 = 0 ;
52318 PyObject * obj0 = 0 ;
52319 PyObject * obj1 = 0 ;
52320 char * kwnames[] = {
52321 (char *) "self",(char *) "window", NULL
52322 };
52323
52324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
52325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52326 if (!SWIG_IsOK(res1)) {
52327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
52328 }
52329 arg1 = reinterpret_cast< wxSizer * >(argp1);
52330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52331 if (!SWIG_IsOK(res2)) {
52332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
52333 }
52334 arg2 = reinterpret_cast< wxWindow * >(argp2);
52335 {
52336 PyThreadState* __tstate = wxPyBeginAllowThreads();
52337 (arg1)->SetContainingWindow(arg2);
52338 wxPyEndAllowThreads(__tstate);
52339 if (PyErr_Occurred()) SWIG_fail;
52340 }
52341 resultobj = SWIG_Py_Void();
52342 return resultobj;
52343 fail:
52344 return NULL;
52345 }
52346
52347
52348 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52349 PyObject *resultobj = 0;
52350 wxSizer *arg1 = (wxSizer *) 0 ;
52351 wxWindow *result = 0 ;
52352 void *argp1 = 0 ;
52353 int res1 = 0 ;
52354 PyObject *swig_obj[1] ;
52355
52356 if (!args) SWIG_fail;
52357 swig_obj[0] = args;
52358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52359 if (!SWIG_IsOK(res1)) {
52360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
52361 }
52362 arg1 = reinterpret_cast< wxSizer * >(argp1);
52363 {
52364 PyThreadState* __tstate = wxPyBeginAllowThreads();
52365 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
52366 wxPyEndAllowThreads(__tstate);
52367 if (PyErr_Occurred()) SWIG_fail;
52368 }
52369 {
52370 resultobj = wxPyMake_wxObject(result, 0);
52371 }
52372 return resultobj;
52373 fail:
52374 return NULL;
52375 }
52376
52377
52378 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52379 PyObject *resultobj = 0;
52380 wxSizer *arg1 = (wxSizer *) 0 ;
52381 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52382 wxSizerItem *result = 0 ;
52383 void *argp1 = 0 ;
52384 int res1 = 0 ;
52385 int res2 = 0 ;
52386 PyObject * obj0 = 0 ;
52387 PyObject * obj1 = 0 ;
52388 char * kwnames[] = {
52389 (char *) "self",(char *) "item", NULL
52390 };
52391
52392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
52393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52394 if (!SWIG_IsOK(res1)) {
52395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52396 }
52397 arg1 = reinterpret_cast< wxSizer * >(argp1);
52398 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52399 if (!SWIG_IsOK(res2)) {
52400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52401 }
52402 {
52403 PyThreadState* __tstate = wxPyBeginAllowThreads();
52404 result = (wxSizerItem *)(arg1)->Add(arg2);
52405 wxPyEndAllowThreads(__tstate);
52406 if (PyErr_Occurred()) SWIG_fail;
52407 }
52408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52409 return resultobj;
52410 fail:
52411 return NULL;
52412 }
52413
52414
52415 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52416 PyObject *resultobj = 0;
52417 wxSizer *arg1 = (wxSizer *) 0 ;
52418 size_t arg2 ;
52419 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52420 wxSizerItem *result = 0 ;
52421 void *argp1 = 0 ;
52422 int res1 = 0 ;
52423 size_t val2 ;
52424 int ecode2 = 0 ;
52425 int res3 = 0 ;
52426 PyObject * obj0 = 0 ;
52427 PyObject * obj1 = 0 ;
52428 PyObject * obj2 = 0 ;
52429 char * kwnames[] = {
52430 (char *) "self",(char *) "index",(char *) "item", NULL
52431 };
52432
52433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52435 if (!SWIG_IsOK(res1)) {
52436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52437 }
52438 arg1 = reinterpret_cast< wxSizer * >(argp1);
52439 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52440 if (!SWIG_IsOK(ecode2)) {
52441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
52442 }
52443 arg2 = static_cast< size_t >(val2);
52444 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52445 if (!SWIG_IsOK(res3)) {
52446 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52447 }
52448 {
52449 PyThreadState* __tstate = wxPyBeginAllowThreads();
52450 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
52451 wxPyEndAllowThreads(__tstate);
52452 if (PyErr_Occurred()) SWIG_fail;
52453 }
52454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52455 return resultobj;
52456 fail:
52457 return NULL;
52458 }
52459
52460
52461 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52462 PyObject *resultobj = 0;
52463 wxSizer *arg1 = (wxSizer *) 0 ;
52464 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52465 wxSizerItem *result = 0 ;
52466 void *argp1 = 0 ;
52467 int res1 = 0 ;
52468 int res2 = 0 ;
52469 PyObject * obj0 = 0 ;
52470 PyObject * obj1 = 0 ;
52471 char * kwnames[] = {
52472 (char *) "self",(char *) "item", NULL
52473 };
52474
52475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
52476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52477 if (!SWIG_IsOK(res1)) {
52478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52479 }
52480 arg1 = reinterpret_cast< wxSizer * >(argp1);
52481 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52482 if (!SWIG_IsOK(res2)) {
52483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52484 }
52485 {
52486 PyThreadState* __tstate = wxPyBeginAllowThreads();
52487 result = (wxSizerItem *)(arg1)->Prepend(arg2);
52488 wxPyEndAllowThreads(__tstate);
52489 if (PyErr_Occurred()) SWIG_fail;
52490 }
52491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52492 return resultobj;
52493 fail:
52494 return NULL;
52495 }
52496
52497
52498 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52499 PyObject *resultobj = 0;
52500 wxSizer *arg1 = (wxSizer *) 0 ;
52501 int arg2 ;
52502 int arg3 ;
52503 int arg4 ;
52504 int arg5 ;
52505 void *argp1 = 0 ;
52506 int res1 = 0 ;
52507 int val2 ;
52508 int ecode2 = 0 ;
52509 int val3 ;
52510 int ecode3 = 0 ;
52511 int val4 ;
52512 int ecode4 = 0 ;
52513 int val5 ;
52514 int ecode5 = 0 ;
52515 PyObject * obj0 = 0 ;
52516 PyObject * obj1 = 0 ;
52517 PyObject * obj2 = 0 ;
52518 PyObject * obj3 = 0 ;
52519 PyObject * obj4 = 0 ;
52520 char * kwnames[] = {
52521 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
52522 };
52523
52524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
52525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52526 if (!SWIG_IsOK(res1)) {
52527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
52528 }
52529 arg1 = reinterpret_cast< wxSizer * >(argp1);
52530 ecode2 = SWIG_AsVal_int(obj1, &val2);
52531 if (!SWIG_IsOK(ecode2)) {
52532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
52533 }
52534 arg2 = static_cast< int >(val2);
52535 ecode3 = SWIG_AsVal_int(obj2, &val3);
52536 if (!SWIG_IsOK(ecode3)) {
52537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
52538 }
52539 arg3 = static_cast< int >(val3);
52540 ecode4 = SWIG_AsVal_int(obj3, &val4);
52541 if (!SWIG_IsOK(ecode4)) {
52542 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
52543 }
52544 arg4 = static_cast< int >(val4);
52545 ecode5 = SWIG_AsVal_int(obj4, &val5);
52546 if (!SWIG_IsOK(ecode5)) {
52547 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
52548 }
52549 arg5 = static_cast< int >(val5);
52550 {
52551 PyThreadState* __tstate = wxPyBeginAllowThreads();
52552 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
52553 wxPyEndAllowThreads(__tstate);
52554 if (PyErr_Occurred()) SWIG_fail;
52555 }
52556 resultobj = SWIG_Py_Void();
52557 return resultobj;
52558 fail:
52559 return NULL;
52560 }
52561
52562
52563 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52564 PyObject *resultobj = 0;
52565 wxSizer *arg1 = (wxSizer *) 0 ;
52566 wxSize *arg2 = 0 ;
52567 void *argp1 = 0 ;
52568 int res1 = 0 ;
52569 wxSize temp2 ;
52570 PyObject * obj0 = 0 ;
52571 PyObject * obj1 = 0 ;
52572 char * kwnames[] = {
52573 (char *) "self",(char *) "size", NULL
52574 };
52575
52576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
52577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52578 if (!SWIG_IsOK(res1)) {
52579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52580 }
52581 arg1 = reinterpret_cast< wxSizer * >(argp1);
52582 {
52583 arg2 = &temp2;
52584 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52585 }
52586 {
52587 PyThreadState* __tstate = wxPyBeginAllowThreads();
52588 (arg1)->SetMinSize((wxSize const &)*arg2);
52589 wxPyEndAllowThreads(__tstate);
52590 if (PyErr_Occurred()) SWIG_fail;
52591 }
52592 resultobj = SWIG_Py_Void();
52593 return resultobj;
52594 fail:
52595 return NULL;
52596 }
52597
52598
52599 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52600 PyObject *resultobj = 0;
52601 wxSizer *arg1 = (wxSizer *) 0 ;
52602 wxSize result;
52603 void *argp1 = 0 ;
52604 int res1 = 0 ;
52605 PyObject *swig_obj[1] ;
52606
52607 if (!args) SWIG_fail;
52608 swig_obj[0] = args;
52609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52610 if (!SWIG_IsOK(res1)) {
52611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52612 }
52613 arg1 = reinterpret_cast< wxSizer * >(argp1);
52614 {
52615 PyThreadState* __tstate = wxPyBeginAllowThreads();
52616 result = (arg1)->GetSize();
52617 wxPyEndAllowThreads(__tstate);
52618 if (PyErr_Occurred()) SWIG_fail;
52619 }
52620 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52621 return resultobj;
52622 fail:
52623 return NULL;
52624 }
52625
52626
52627 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52628 PyObject *resultobj = 0;
52629 wxSizer *arg1 = (wxSizer *) 0 ;
52630 wxPoint result;
52631 void *argp1 = 0 ;
52632 int res1 = 0 ;
52633 PyObject *swig_obj[1] ;
52634
52635 if (!args) SWIG_fail;
52636 swig_obj[0] = args;
52637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52638 if (!SWIG_IsOK(res1)) {
52639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
52640 }
52641 arg1 = reinterpret_cast< wxSizer * >(argp1);
52642 {
52643 PyThreadState* __tstate = wxPyBeginAllowThreads();
52644 result = (arg1)->GetPosition();
52645 wxPyEndAllowThreads(__tstate);
52646 if (PyErr_Occurred()) SWIG_fail;
52647 }
52648 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
52649 return resultobj;
52650 fail:
52651 return NULL;
52652 }
52653
52654
52655 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52656 PyObject *resultobj = 0;
52657 wxSizer *arg1 = (wxSizer *) 0 ;
52658 wxSize result;
52659 void *argp1 = 0 ;
52660 int res1 = 0 ;
52661 PyObject *swig_obj[1] ;
52662
52663 if (!args) SWIG_fail;
52664 swig_obj[0] = args;
52665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52666 if (!SWIG_IsOK(res1)) {
52667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52668 }
52669 arg1 = reinterpret_cast< wxSizer * >(argp1);
52670 {
52671 PyThreadState* __tstate = wxPyBeginAllowThreads();
52672 result = (arg1)->GetMinSize();
52673 wxPyEndAllowThreads(__tstate);
52674 if (PyErr_Occurred()) SWIG_fail;
52675 }
52676 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52677 return resultobj;
52678 fail:
52679 return NULL;
52680 }
52681
52682
52683 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52684 PyObject *resultobj = 0;
52685 wxSizer *arg1 = (wxSizer *) 0 ;
52686 void *argp1 = 0 ;
52687 int res1 = 0 ;
52688 PyObject *swig_obj[1] ;
52689
52690 if (!args) SWIG_fail;
52691 swig_obj[0] = args;
52692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52693 if (!SWIG_IsOK(res1)) {
52694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
52695 }
52696 arg1 = reinterpret_cast< wxSizer * >(argp1);
52697 {
52698 PyThreadState* __tstate = wxPyBeginAllowThreads();
52699 (arg1)->RecalcSizes();
52700 wxPyEndAllowThreads(__tstate);
52701 if (PyErr_Occurred()) SWIG_fail;
52702 }
52703 resultobj = SWIG_Py_Void();
52704 return resultobj;
52705 fail:
52706 return NULL;
52707 }
52708
52709
52710 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52711 PyObject *resultobj = 0;
52712 wxSizer *arg1 = (wxSizer *) 0 ;
52713 wxSize result;
52714 void *argp1 = 0 ;
52715 int res1 = 0 ;
52716 PyObject *swig_obj[1] ;
52717
52718 if (!args) SWIG_fail;
52719 swig_obj[0] = args;
52720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52721 if (!SWIG_IsOK(res1)) {
52722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52723 }
52724 arg1 = reinterpret_cast< wxSizer * >(argp1);
52725 {
52726 PyThreadState* __tstate = wxPyBeginAllowThreads();
52727 result = (arg1)->CalcMin();
52728 wxPyEndAllowThreads(__tstate);
52729 if (PyErr_Occurred()) SWIG_fail;
52730 }
52731 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52732 return resultobj;
52733 fail:
52734 return NULL;
52735 }
52736
52737
52738 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52739 PyObject *resultobj = 0;
52740 wxSizer *arg1 = (wxSizer *) 0 ;
52741 void *argp1 = 0 ;
52742 int res1 = 0 ;
52743 PyObject *swig_obj[1] ;
52744
52745 if (!args) SWIG_fail;
52746 swig_obj[0] = args;
52747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52748 if (!SWIG_IsOK(res1)) {
52749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52750 }
52751 arg1 = reinterpret_cast< wxSizer * >(argp1);
52752 {
52753 PyThreadState* __tstate = wxPyBeginAllowThreads();
52754 (arg1)->Layout();
52755 wxPyEndAllowThreads(__tstate);
52756 if (PyErr_Occurred()) SWIG_fail;
52757 }
52758 resultobj = SWIG_Py_Void();
52759 return resultobj;
52760 fail:
52761 return NULL;
52762 }
52763
52764
52765 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52766 PyObject *resultobj = 0;
52767 wxSizer *arg1 = (wxSizer *) 0 ;
52768 wxWindow *arg2 = (wxWindow *) 0 ;
52769 wxSize result;
52770 void *argp1 = 0 ;
52771 int res1 = 0 ;
52772 void *argp2 = 0 ;
52773 int res2 = 0 ;
52774 PyObject * obj0 = 0 ;
52775 PyObject * obj1 = 0 ;
52776 char * kwnames[] = {
52777 (char *) "self",(char *) "window", NULL
52778 };
52779
52780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52782 if (!SWIG_IsOK(res1)) {
52783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52784 }
52785 arg1 = reinterpret_cast< wxSizer * >(argp1);
52786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52787 if (!SWIG_IsOK(res2)) {
52788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52789 }
52790 arg2 = reinterpret_cast< wxWindow * >(argp2);
52791 {
52792 PyThreadState* __tstate = wxPyBeginAllowThreads();
52793 result = (arg1)->Fit(arg2);
52794 wxPyEndAllowThreads(__tstate);
52795 if (PyErr_Occurred()) SWIG_fail;
52796 }
52797 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52798 return resultobj;
52799 fail:
52800 return NULL;
52801 }
52802
52803
52804 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52805 PyObject *resultobj = 0;
52806 wxSizer *arg1 = (wxSizer *) 0 ;
52807 wxWindow *arg2 = (wxWindow *) 0 ;
52808 void *argp1 = 0 ;
52809 int res1 = 0 ;
52810 void *argp2 = 0 ;
52811 int res2 = 0 ;
52812 PyObject * obj0 = 0 ;
52813 PyObject * obj1 = 0 ;
52814 char * kwnames[] = {
52815 (char *) "self",(char *) "window", NULL
52816 };
52817
52818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52820 if (!SWIG_IsOK(res1)) {
52821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52822 }
52823 arg1 = reinterpret_cast< wxSizer * >(argp1);
52824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52825 if (!SWIG_IsOK(res2)) {
52826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52827 }
52828 arg2 = reinterpret_cast< wxWindow * >(argp2);
52829 {
52830 PyThreadState* __tstate = wxPyBeginAllowThreads();
52831 (arg1)->FitInside(arg2);
52832 wxPyEndAllowThreads(__tstate);
52833 if (PyErr_Occurred()) SWIG_fail;
52834 }
52835 resultobj = SWIG_Py_Void();
52836 return resultobj;
52837 fail:
52838 return NULL;
52839 }
52840
52841
52842 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52843 PyObject *resultobj = 0;
52844 wxSizer *arg1 = (wxSizer *) 0 ;
52845 wxWindow *arg2 = (wxWindow *) 0 ;
52846 void *argp1 = 0 ;
52847 int res1 = 0 ;
52848 void *argp2 = 0 ;
52849 int res2 = 0 ;
52850 PyObject * obj0 = 0 ;
52851 PyObject * obj1 = 0 ;
52852 char * kwnames[] = {
52853 (char *) "self",(char *) "window", NULL
52854 };
52855
52856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52858 if (!SWIG_IsOK(res1)) {
52859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52860 }
52861 arg1 = reinterpret_cast< wxSizer * >(argp1);
52862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52863 if (!SWIG_IsOK(res2)) {
52864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52865 }
52866 arg2 = reinterpret_cast< wxWindow * >(argp2);
52867 {
52868 PyThreadState* __tstate = wxPyBeginAllowThreads();
52869 (arg1)->SetSizeHints(arg2);
52870 wxPyEndAllowThreads(__tstate);
52871 if (PyErr_Occurred()) SWIG_fail;
52872 }
52873 resultobj = SWIG_Py_Void();
52874 return resultobj;
52875 fail:
52876 return NULL;
52877 }
52878
52879
52880 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52881 PyObject *resultobj = 0;
52882 wxSizer *arg1 = (wxSizer *) 0 ;
52883 wxWindow *arg2 = (wxWindow *) 0 ;
52884 void *argp1 = 0 ;
52885 int res1 = 0 ;
52886 void *argp2 = 0 ;
52887 int res2 = 0 ;
52888 PyObject * obj0 = 0 ;
52889 PyObject * obj1 = 0 ;
52890 char * kwnames[] = {
52891 (char *) "self",(char *) "window", NULL
52892 };
52893
52894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52896 if (!SWIG_IsOK(res1)) {
52897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52898 }
52899 arg1 = reinterpret_cast< wxSizer * >(argp1);
52900 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52901 if (!SWIG_IsOK(res2)) {
52902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52903 }
52904 arg2 = reinterpret_cast< wxWindow * >(argp2);
52905 {
52906 PyThreadState* __tstate = wxPyBeginAllowThreads();
52907 (arg1)->SetVirtualSizeHints(arg2);
52908 wxPyEndAllowThreads(__tstate);
52909 if (PyErr_Occurred()) SWIG_fail;
52910 }
52911 resultobj = SWIG_Py_Void();
52912 return resultobj;
52913 fail:
52914 return NULL;
52915 }
52916
52917
52918 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52919 PyObject *resultobj = 0;
52920 wxSizer *arg1 = (wxSizer *) 0 ;
52921 bool arg2 = (bool) false ;
52922 void *argp1 = 0 ;
52923 int res1 = 0 ;
52924 bool val2 ;
52925 int ecode2 = 0 ;
52926 PyObject * obj0 = 0 ;
52927 PyObject * obj1 = 0 ;
52928 char * kwnames[] = {
52929 (char *) "self",(char *) "deleteWindows", NULL
52930 };
52931
52932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52934 if (!SWIG_IsOK(res1)) {
52935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52936 }
52937 arg1 = reinterpret_cast< wxSizer * >(argp1);
52938 if (obj1) {
52939 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52940 if (!SWIG_IsOK(ecode2)) {
52941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52942 }
52943 arg2 = static_cast< bool >(val2);
52944 }
52945 {
52946 PyThreadState* __tstate = wxPyBeginAllowThreads();
52947 (arg1)->Clear(arg2);
52948 wxPyEndAllowThreads(__tstate);
52949 if (PyErr_Occurred()) SWIG_fail;
52950 }
52951 resultobj = SWIG_Py_Void();
52952 return resultobj;
52953 fail:
52954 return NULL;
52955 }
52956
52957
52958 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52959 PyObject *resultobj = 0;
52960 wxSizer *arg1 = (wxSizer *) 0 ;
52961 void *argp1 = 0 ;
52962 int res1 = 0 ;
52963 PyObject *swig_obj[1] ;
52964
52965 if (!args) SWIG_fail;
52966 swig_obj[0] = args;
52967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52968 if (!SWIG_IsOK(res1)) {
52969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52970 }
52971 arg1 = reinterpret_cast< wxSizer * >(argp1);
52972 {
52973 PyThreadState* __tstate = wxPyBeginAllowThreads();
52974 (arg1)->DeleteWindows();
52975 wxPyEndAllowThreads(__tstate);
52976 if (PyErr_Occurred()) SWIG_fail;
52977 }
52978 resultobj = SWIG_Py_Void();
52979 return resultobj;
52980 fail:
52981 return NULL;
52982 }
52983
52984
52985 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52986 PyObject *resultobj = 0;
52987 wxSizer *arg1 = (wxSizer *) 0 ;
52988 PyObject *result = 0 ;
52989 void *argp1 = 0 ;
52990 int res1 = 0 ;
52991 PyObject *swig_obj[1] ;
52992
52993 if (!args) SWIG_fail;
52994 swig_obj[0] = args;
52995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52996 if (!SWIG_IsOK(res1)) {
52997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52998 }
52999 arg1 = reinterpret_cast< wxSizer * >(argp1);
53000 {
53001 PyThreadState* __tstate = wxPyBeginAllowThreads();
53002 result = (PyObject *)wxSizer_GetChildren(arg1);
53003 wxPyEndAllowThreads(__tstate);
53004 if (PyErr_Occurred()) SWIG_fail;
53005 }
53006 resultobj = result;
53007 return resultobj;
53008 fail:
53009 return NULL;
53010 }
53011
53012
53013 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53014 PyObject *resultobj = 0;
53015 wxSizer *arg1 = (wxSizer *) 0 ;
53016 PyObject *arg2 = (PyObject *) 0 ;
53017 bool arg3 = (bool) true ;
53018 bool arg4 = (bool) false ;
53019 bool result;
53020 void *argp1 = 0 ;
53021 int res1 = 0 ;
53022 bool val3 ;
53023 int ecode3 = 0 ;
53024 bool val4 ;
53025 int ecode4 = 0 ;
53026 PyObject * obj0 = 0 ;
53027 PyObject * obj1 = 0 ;
53028 PyObject * obj2 = 0 ;
53029 PyObject * obj3 = 0 ;
53030 char * kwnames[] = {
53031 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
53032 };
53033
53034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53036 if (!SWIG_IsOK(res1)) {
53037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
53038 }
53039 arg1 = reinterpret_cast< wxSizer * >(argp1);
53040 arg2 = obj1;
53041 if (obj2) {
53042 ecode3 = SWIG_AsVal_bool(obj2, &val3);
53043 if (!SWIG_IsOK(ecode3)) {
53044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
53045 }
53046 arg3 = static_cast< bool >(val3);
53047 }
53048 if (obj3) {
53049 ecode4 = SWIG_AsVal_bool(obj3, &val4);
53050 if (!SWIG_IsOK(ecode4)) {
53051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
53052 }
53053 arg4 = static_cast< bool >(val4);
53054 }
53055 {
53056 PyThreadState* __tstate = wxPyBeginAllowThreads();
53057 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
53058 wxPyEndAllowThreads(__tstate);
53059 if (PyErr_Occurred()) SWIG_fail;
53060 }
53061 {
53062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53063 }
53064 return resultobj;
53065 fail:
53066 return NULL;
53067 }
53068
53069
53070 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53071 PyObject *resultobj = 0;
53072 wxSizer *arg1 = (wxSizer *) 0 ;
53073 PyObject *arg2 = (PyObject *) 0 ;
53074 bool result;
53075 void *argp1 = 0 ;
53076 int res1 = 0 ;
53077 PyObject * obj0 = 0 ;
53078 PyObject * obj1 = 0 ;
53079 char * kwnames[] = {
53080 (char *) "self",(char *) "item", NULL
53081 };
53082
53083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
53084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53085 if (!SWIG_IsOK(res1)) {
53086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
53087 }
53088 arg1 = reinterpret_cast< wxSizer * >(argp1);
53089 arg2 = obj1;
53090 {
53091 PyThreadState* __tstate = wxPyBeginAllowThreads();
53092 result = (bool)wxSizer_IsShown(arg1,arg2);
53093 wxPyEndAllowThreads(__tstate);
53094 if (PyErr_Occurred()) SWIG_fail;
53095 }
53096 {
53097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53098 }
53099 return resultobj;
53100 fail:
53101 return NULL;
53102 }
53103
53104
53105 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53106 PyObject *resultobj = 0;
53107 wxSizer *arg1 = (wxSizer *) 0 ;
53108 bool arg2 ;
53109 void *argp1 = 0 ;
53110 int res1 = 0 ;
53111 bool val2 ;
53112 int ecode2 = 0 ;
53113 PyObject * obj0 = 0 ;
53114 PyObject * obj1 = 0 ;
53115 char * kwnames[] = {
53116 (char *) "self",(char *) "show", NULL
53117 };
53118
53119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
53120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53121 if (!SWIG_IsOK(res1)) {
53122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
53123 }
53124 arg1 = reinterpret_cast< wxSizer * >(argp1);
53125 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53126 if (!SWIG_IsOK(ecode2)) {
53127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
53128 }
53129 arg2 = static_cast< bool >(val2);
53130 {
53131 PyThreadState* __tstate = wxPyBeginAllowThreads();
53132 (arg1)->ShowItems(arg2);
53133 wxPyEndAllowThreads(__tstate);
53134 if (PyErr_Occurred()) SWIG_fail;
53135 }
53136 resultobj = SWIG_Py_Void();
53137 return resultobj;
53138 fail:
53139 return NULL;
53140 }
53141
53142
53143 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53144 PyObject *obj;
53145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53146 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
53147 return SWIG_Py_Void();
53148 }
53149
53150 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53151 PyObject *resultobj = 0;
53152 wxPySizer *result = 0 ;
53153
53154 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
53155 {
53156 PyThreadState* __tstate = wxPyBeginAllowThreads();
53157 result = (wxPySizer *)new wxPySizer();
53158 wxPyEndAllowThreads(__tstate);
53159 if (PyErr_Occurred()) SWIG_fail;
53160 }
53161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
53162 return resultobj;
53163 fail:
53164 return NULL;
53165 }
53166
53167
53168 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53169 PyObject *resultobj = 0;
53170 wxPySizer *arg1 = (wxPySizer *) 0 ;
53171 PyObject *arg2 = (PyObject *) 0 ;
53172 PyObject *arg3 = (PyObject *) 0 ;
53173 void *argp1 = 0 ;
53174 int res1 = 0 ;
53175 PyObject * obj0 = 0 ;
53176 PyObject * obj1 = 0 ;
53177 PyObject * obj2 = 0 ;
53178 char * kwnames[] = {
53179 (char *) "self",(char *) "self",(char *) "_class", NULL
53180 };
53181
53182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
53184 if (!SWIG_IsOK(res1)) {
53185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
53186 }
53187 arg1 = reinterpret_cast< wxPySizer * >(argp1);
53188 arg2 = obj1;
53189 arg3 = obj2;
53190 {
53191 PyThreadState* __tstate = wxPyBeginAllowThreads();
53192 (arg1)->_setCallbackInfo(arg2,arg3);
53193 wxPyEndAllowThreads(__tstate);
53194 if (PyErr_Occurred()) SWIG_fail;
53195 }
53196 resultobj = SWIG_Py_Void();
53197 return resultobj;
53198 fail:
53199 return NULL;
53200 }
53201
53202
53203 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53204 PyObject *obj;
53205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53206 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
53207 return SWIG_Py_Void();
53208 }
53209
53210 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53211 return SWIG_Python_InitShadowInstance(args);
53212 }
53213
53214 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53215 PyObject *resultobj = 0;
53216 int arg1 = (int) wxHORIZONTAL ;
53217 wxBoxSizer *result = 0 ;
53218 int val1 ;
53219 int ecode1 = 0 ;
53220 PyObject * obj0 = 0 ;
53221 char * kwnames[] = {
53222 (char *) "orient", NULL
53223 };
53224
53225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
53226 if (obj0) {
53227 ecode1 = SWIG_AsVal_int(obj0, &val1);
53228 if (!SWIG_IsOK(ecode1)) {
53229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
53230 }
53231 arg1 = static_cast< int >(val1);
53232 }
53233 {
53234 PyThreadState* __tstate = wxPyBeginAllowThreads();
53235 result = (wxBoxSizer *)new wxBoxSizer(arg1);
53236 wxPyEndAllowThreads(__tstate);
53237 if (PyErr_Occurred()) SWIG_fail;
53238 }
53239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
53240 return resultobj;
53241 fail:
53242 return NULL;
53243 }
53244
53245
53246 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53247 PyObject *resultobj = 0;
53248 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53249 int result;
53250 void *argp1 = 0 ;
53251 int res1 = 0 ;
53252 PyObject *swig_obj[1] ;
53253
53254 if (!args) SWIG_fail;
53255 swig_obj[0] = args;
53256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53257 if (!SWIG_IsOK(res1)) {
53258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53259 }
53260 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53261 {
53262 PyThreadState* __tstate = wxPyBeginAllowThreads();
53263 result = (int)(arg1)->GetOrientation();
53264 wxPyEndAllowThreads(__tstate);
53265 if (PyErr_Occurred()) SWIG_fail;
53266 }
53267 resultobj = SWIG_From_int(static_cast< int >(result));
53268 return resultobj;
53269 fail:
53270 return NULL;
53271 }
53272
53273
53274 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53275 PyObject *resultobj = 0;
53276 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53277 int arg2 ;
53278 void *argp1 = 0 ;
53279 int res1 = 0 ;
53280 int val2 ;
53281 int ecode2 = 0 ;
53282 PyObject * obj0 = 0 ;
53283 PyObject * obj1 = 0 ;
53284 char * kwnames[] = {
53285 (char *) "self",(char *) "orient", NULL
53286 };
53287
53288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
53289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53290 if (!SWIG_IsOK(res1)) {
53291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53292 }
53293 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53294 ecode2 = SWIG_AsVal_int(obj1, &val2);
53295 if (!SWIG_IsOK(ecode2)) {
53296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
53297 }
53298 arg2 = static_cast< int >(val2);
53299 {
53300 PyThreadState* __tstate = wxPyBeginAllowThreads();
53301 (arg1)->SetOrientation(arg2);
53302 wxPyEndAllowThreads(__tstate);
53303 if (PyErr_Occurred()) SWIG_fail;
53304 }
53305 resultobj = SWIG_Py_Void();
53306 return resultobj;
53307 fail:
53308 return NULL;
53309 }
53310
53311
53312 SWIGINTERN PyObject *_wrap_BoxSizer_IsVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53313 PyObject *resultobj = 0;
53314 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53315 bool result;
53316 void *argp1 = 0 ;
53317 int res1 = 0 ;
53318 PyObject *swig_obj[1] ;
53319
53320 if (!args) SWIG_fail;
53321 swig_obj[0] = args;
53322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53323 if (!SWIG_IsOK(res1)) {
53324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_IsVertical" "', expected argument " "1"" of type '" "wxBoxSizer const *""'");
53325 }
53326 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53327 {
53328 PyThreadState* __tstate = wxPyBeginAllowThreads();
53329 result = (bool)((wxBoxSizer const *)arg1)->IsVertical();
53330 wxPyEndAllowThreads(__tstate);
53331 if (PyErr_Occurred()) SWIG_fail;
53332 }
53333 {
53334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53335 }
53336 return resultobj;
53337 fail:
53338 return NULL;
53339 }
53340
53341
53342 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53343 PyObject *obj;
53344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53345 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
53346 return SWIG_Py_Void();
53347 }
53348
53349 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53350 return SWIG_Python_InitShadowInstance(args);
53351 }
53352
53353 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53354 PyObject *resultobj = 0;
53355 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
53356 int arg2 = (int) wxHORIZONTAL ;
53357 wxStaticBoxSizer *result = 0 ;
53358 void *argp1 = 0 ;
53359 int res1 = 0 ;
53360 int val2 ;
53361 int ecode2 = 0 ;
53362 PyObject * obj0 = 0 ;
53363 PyObject * obj1 = 0 ;
53364 char * kwnames[] = {
53365 (char *) "box",(char *) "orient", NULL
53366 };
53367
53368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
53370 if (!SWIG_IsOK(res1)) {
53371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
53372 }
53373 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
53374 if (obj1) {
53375 ecode2 = SWIG_AsVal_int(obj1, &val2);
53376 if (!SWIG_IsOK(ecode2)) {
53377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
53378 }
53379 arg2 = static_cast< int >(val2);
53380 }
53381 {
53382 PyThreadState* __tstate = wxPyBeginAllowThreads();
53383 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
53384 wxPyEndAllowThreads(__tstate);
53385 if (PyErr_Occurred()) SWIG_fail;
53386 }
53387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
53388 return resultobj;
53389 fail:
53390 return NULL;
53391 }
53392
53393
53394 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53395 PyObject *resultobj = 0;
53396 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
53397 wxStaticBox *result = 0 ;
53398 void *argp1 = 0 ;
53399 int res1 = 0 ;
53400 PyObject *swig_obj[1] ;
53401
53402 if (!args) SWIG_fail;
53403 swig_obj[0] = args;
53404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
53405 if (!SWIG_IsOK(res1)) {
53406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
53407 }
53408 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
53409 {
53410 PyThreadState* __tstate = wxPyBeginAllowThreads();
53411 result = (wxStaticBox *)(arg1)->GetStaticBox();
53412 wxPyEndAllowThreads(__tstate);
53413 if (PyErr_Occurred()) SWIG_fail;
53414 }
53415 {
53416 resultobj = wxPyMake_wxObject(result, (bool)0);
53417 }
53418 return resultobj;
53419 fail:
53420 return NULL;
53421 }
53422
53423
53424 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53425 PyObject *obj;
53426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53427 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
53428 return SWIG_Py_Void();
53429 }
53430
53431 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53432 return SWIG_Python_InitShadowInstance(args);
53433 }
53434
53435 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53436 PyObject *resultobj = 0;
53437 int arg1 = (int) 1 ;
53438 int arg2 = (int) 0 ;
53439 int arg3 = (int) 0 ;
53440 int arg4 = (int) 0 ;
53441 wxGridSizer *result = 0 ;
53442 int val1 ;
53443 int ecode1 = 0 ;
53444 int val2 ;
53445 int ecode2 = 0 ;
53446 int val3 ;
53447 int ecode3 = 0 ;
53448 int val4 ;
53449 int ecode4 = 0 ;
53450 PyObject * obj0 = 0 ;
53451 PyObject * obj1 = 0 ;
53452 PyObject * obj2 = 0 ;
53453 PyObject * obj3 = 0 ;
53454 char * kwnames[] = {
53455 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53456 };
53457
53458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53459 if (obj0) {
53460 ecode1 = SWIG_AsVal_int(obj0, &val1);
53461 if (!SWIG_IsOK(ecode1)) {
53462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
53463 }
53464 arg1 = static_cast< int >(val1);
53465 }
53466 if (obj1) {
53467 ecode2 = SWIG_AsVal_int(obj1, &val2);
53468 if (!SWIG_IsOK(ecode2)) {
53469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
53470 }
53471 arg2 = static_cast< int >(val2);
53472 }
53473 if (obj2) {
53474 ecode3 = SWIG_AsVal_int(obj2, &val3);
53475 if (!SWIG_IsOK(ecode3)) {
53476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
53477 }
53478 arg3 = static_cast< int >(val3);
53479 }
53480 if (obj3) {
53481 ecode4 = SWIG_AsVal_int(obj3, &val4);
53482 if (!SWIG_IsOK(ecode4)) {
53483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
53484 }
53485 arg4 = static_cast< int >(val4);
53486 }
53487 {
53488 PyThreadState* __tstate = wxPyBeginAllowThreads();
53489 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
53490 wxPyEndAllowThreads(__tstate);
53491 if (PyErr_Occurred()) SWIG_fail;
53492 }
53493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
53494 return resultobj;
53495 fail:
53496 return NULL;
53497 }
53498
53499
53500 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53501 PyObject *resultobj = 0;
53502 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53503 int arg2 ;
53504 void *argp1 = 0 ;
53505 int res1 = 0 ;
53506 int val2 ;
53507 int ecode2 = 0 ;
53508 PyObject * obj0 = 0 ;
53509 PyObject * obj1 = 0 ;
53510 char * kwnames[] = {
53511 (char *) "self",(char *) "cols", NULL
53512 };
53513
53514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
53515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53516 if (!SWIG_IsOK(res1)) {
53517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53518 }
53519 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53520 ecode2 = SWIG_AsVal_int(obj1, &val2);
53521 if (!SWIG_IsOK(ecode2)) {
53522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
53523 }
53524 arg2 = static_cast< int >(val2);
53525 {
53526 PyThreadState* __tstate = wxPyBeginAllowThreads();
53527 (arg1)->SetCols(arg2);
53528 wxPyEndAllowThreads(__tstate);
53529 if (PyErr_Occurred()) SWIG_fail;
53530 }
53531 resultobj = SWIG_Py_Void();
53532 return resultobj;
53533 fail:
53534 return NULL;
53535 }
53536
53537
53538 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53539 PyObject *resultobj = 0;
53540 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53541 int arg2 ;
53542 void *argp1 = 0 ;
53543 int res1 = 0 ;
53544 int val2 ;
53545 int ecode2 = 0 ;
53546 PyObject * obj0 = 0 ;
53547 PyObject * obj1 = 0 ;
53548 char * kwnames[] = {
53549 (char *) "self",(char *) "rows", NULL
53550 };
53551
53552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
53553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53554 if (!SWIG_IsOK(res1)) {
53555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53556 }
53557 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53558 ecode2 = SWIG_AsVal_int(obj1, &val2);
53559 if (!SWIG_IsOK(ecode2)) {
53560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
53561 }
53562 arg2 = static_cast< int >(val2);
53563 {
53564 PyThreadState* __tstate = wxPyBeginAllowThreads();
53565 (arg1)->SetRows(arg2);
53566 wxPyEndAllowThreads(__tstate);
53567 if (PyErr_Occurred()) SWIG_fail;
53568 }
53569 resultobj = SWIG_Py_Void();
53570 return resultobj;
53571 fail:
53572 return NULL;
53573 }
53574
53575
53576 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53577 PyObject *resultobj = 0;
53578 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53579 int arg2 ;
53580 void *argp1 = 0 ;
53581 int res1 = 0 ;
53582 int val2 ;
53583 int ecode2 = 0 ;
53584 PyObject * obj0 = 0 ;
53585 PyObject * obj1 = 0 ;
53586 char * kwnames[] = {
53587 (char *) "self",(char *) "gap", NULL
53588 };
53589
53590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
53591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53592 if (!SWIG_IsOK(res1)) {
53593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53594 }
53595 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53596 ecode2 = SWIG_AsVal_int(obj1, &val2);
53597 if (!SWIG_IsOK(ecode2)) {
53598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
53599 }
53600 arg2 = static_cast< int >(val2);
53601 {
53602 PyThreadState* __tstate = wxPyBeginAllowThreads();
53603 (arg1)->SetVGap(arg2);
53604 wxPyEndAllowThreads(__tstate);
53605 if (PyErr_Occurred()) SWIG_fail;
53606 }
53607 resultobj = SWIG_Py_Void();
53608 return resultobj;
53609 fail:
53610 return NULL;
53611 }
53612
53613
53614 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53615 PyObject *resultobj = 0;
53616 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53617 int arg2 ;
53618 void *argp1 = 0 ;
53619 int res1 = 0 ;
53620 int val2 ;
53621 int ecode2 = 0 ;
53622 PyObject * obj0 = 0 ;
53623 PyObject * obj1 = 0 ;
53624 char * kwnames[] = {
53625 (char *) "self",(char *) "gap", NULL
53626 };
53627
53628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
53629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53630 if (!SWIG_IsOK(res1)) {
53631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53632 }
53633 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53634 ecode2 = SWIG_AsVal_int(obj1, &val2);
53635 if (!SWIG_IsOK(ecode2)) {
53636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
53637 }
53638 arg2 = static_cast< int >(val2);
53639 {
53640 PyThreadState* __tstate = wxPyBeginAllowThreads();
53641 (arg1)->SetHGap(arg2);
53642 wxPyEndAllowThreads(__tstate);
53643 if (PyErr_Occurred()) SWIG_fail;
53644 }
53645 resultobj = SWIG_Py_Void();
53646 return resultobj;
53647 fail:
53648 return NULL;
53649 }
53650
53651
53652 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53653 PyObject *resultobj = 0;
53654 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53655 int result;
53656 void *argp1 = 0 ;
53657 int res1 = 0 ;
53658 PyObject *swig_obj[1] ;
53659
53660 if (!args) SWIG_fail;
53661 swig_obj[0] = args;
53662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53663 if (!SWIG_IsOK(res1)) {
53664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53665 }
53666 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53667 {
53668 PyThreadState* __tstate = wxPyBeginAllowThreads();
53669 result = (int)(arg1)->GetCols();
53670 wxPyEndAllowThreads(__tstate);
53671 if (PyErr_Occurred()) SWIG_fail;
53672 }
53673 resultobj = SWIG_From_int(static_cast< int >(result));
53674 return resultobj;
53675 fail:
53676 return NULL;
53677 }
53678
53679
53680 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53681 PyObject *resultobj = 0;
53682 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53683 int result;
53684 void *argp1 = 0 ;
53685 int res1 = 0 ;
53686 PyObject *swig_obj[1] ;
53687
53688 if (!args) SWIG_fail;
53689 swig_obj[0] = args;
53690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53691 if (!SWIG_IsOK(res1)) {
53692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53693 }
53694 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53695 {
53696 PyThreadState* __tstate = wxPyBeginAllowThreads();
53697 result = (int)(arg1)->GetRows();
53698 wxPyEndAllowThreads(__tstate);
53699 if (PyErr_Occurred()) SWIG_fail;
53700 }
53701 resultobj = SWIG_From_int(static_cast< int >(result));
53702 return resultobj;
53703 fail:
53704 return NULL;
53705 }
53706
53707
53708 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53709 PyObject *resultobj = 0;
53710 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53711 int result;
53712 void *argp1 = 0 ;
53713 int res1 = 0 ;
53714 PyObject *swig_obj[1] ;
53715
53716 if (!args) SWIG_fail;
53717 swig_obj[0] = args;
53718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53719 if (!SWIG_IsOK(res1)) {
53720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53721 }
53722 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53723 {
53724 PyThreadState* __tstate = wxPyBeginAllowThreads();
53725 result = (int)(arg1)->GetVGap();
53726 wxPyEndAllowThreads(__tstate);
53727 if (PyErr_Occurred()) SWIG_fail;
53728 }
53729 resultobj = SWIG_From_int(static_cast< int >(result));
53730 return resultobj;
53731 fail:
53732 return NULL;
53733 }
53734
53735
53736 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53737 PyObject *resultobj = 0;
53738 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53739 int result;
53740 void *argp1 = 0 ;
53741 int res1 = 0 ;
53742 PyObject *swig_obj[1] ;
53743
53744 if (!args) SWIG_fail;
53745 swig_obj[0] = args;
53746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53747 if (!SWIG_IsOK(res1)) {
53748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53749 }
53750 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53751 {
53752 PyThreadState* __tstate = wxPyBeginAllowThreads();
53753 result = (int)(arg1)->GetHGap();
53754 wxPyEndAllowThreads(__tstate);
53755 if (PyErr_Occurred()) SWIG_fail;
53756 }
53757 resultobj = SWIG_From_int(static_cast< int >(result));
53758 return resultobj;
53759 fail:
53760 return NULL;
53761 }
53762
53763
53764 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53765 PyObject *obj;
53766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53767 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53768 return SWIG_Py_Void();
53769 }
53770
53771 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53772 return SWIG_Python_InitShadowInstance(args);
53773 }
53774
53775 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53776 PyObject *resultobj = 0;
53777 int arg1 = (int) 1 ;
53778 int arg2 = (int) 0 ;
53779 int arg3 = (int) 0 ;
53780 int arg4 = (int) 0 ;
53781 wxFlexGridSizer *result = 0 ;
53782 int val1 ;
53783 int ecode1 = 0 ;
53784 int val2 ;
53785 int ecode2 = 0 ;
53786 int val3 ;
53787 int ecode3 = 0 ;
53788 int val4 ;
53789 int ecode4 = 0 ;
53790 PyObject * obj0 = 0 ;
53791 PyObject * obj1 = 0 ;
53792 PyObject * obj2 = 0 ;
53793 PyObject * obj3 = 0 ;
53794 char * kwnames[] = {
53795 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53796 };
53797
53798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53799 if (obj0) {
53800 ecode1 = SWIG_AsVal_int(obj0, &val1);
53801 if (!SWIG_IsOK(ecode1)) {
53802 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53803 }
53804 arg1 = static_cast< int >(val1);
53805 }
53806 if (obj1) {
53807 ecode2 = SWIG_AsVal_int(obj1, &val2);
53808 if (!SWIG_IsOK(ecode2)) {
53809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53810 }
53811 arg2 = static_cast< int >(val2);
53812 }
53813 if (obj2) {
53814 ecode3 = SWIG_AsVal_int(obj2, &val3);
53815 if (!SWIG_IsOK(ecode3)) {
53816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53817 }
53818 arg3 = static_cast< int >(val3);
53819 }
53820 if (obj3) {
53821 ecode4 = SWIG_AsVal_int(obj3, &val4);
53822 if (!SWIG_IsOK(ecode4)) {
53823 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53824 }
53825 arg4 = static_cast< int >(val4);
53826 }
53827 {
53828 PyThreadState* __tstate = wxPyBeginAllowThreads();
53829 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53830 wxPyEndAllowThreads(__tstate);
53831 if (PyErr_Occurred()) SWIG_fail;
53832 }
53833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53834 return resultobj;
53835 fail:
53836 return NULL;
53837 }
53838
53839
53840 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53841 PyObject *resultobj = 0;
53842 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53843 size_t arg2 ;
53844 int arg3 = (int) 0 ;
53845 void *argp1 = 0 ;
53846 int res1 = 0 ;
53847 size_t val2 ;
53848 int ecode2 = 0 ;
53849 int val3 ;
53850 int ecode3 = 0 ;
53851 PyObject * obj0 = 0 ;
53852 PyObject * obj1 = 0 ;
53853 PyObject * obj2 = 0 ;
53854 char * kwnames[] = {
53855 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53856 };
53857
53858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53860 if (!SWIG_IsOK(res1)) {
53861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53862 }
53863 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53864 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53865 if (!SWIG_IsOK(ecode2)) {
53866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53867 }
53868 arg2 = static_cast< size_t >(val2);
53869 if (obj2) {
53870 ecode3 = SWIG_AsVal_int(obj2, &val3);
53871 if (!SWIG_IsOK(ecode3)) {
53872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53873 }
53874 arg3 = static_cast< int >(val3);
53875 }
53876 {
53877 PyThreadState* __tstate = wxPyBeginAllowThreads();
53878 (arg1)->AddGrowableRow(arg2,arg3);
53879 wxPyEndAllowThreads(__tstate);
53880 if (PyErr_Occurred()) SWIG_fail;
53881 }
53882 resultobj = SWIG_Py_Void();
53883 return resultobj;
53884 fail:
53885 return NULL;
53886 }
53887
53888
53889 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53890 PyObject *resultobj = 0;
53891 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53892 size_t arg2 ;
53893 void *argp1 = 0 ;
53894 int res1 = 0 ;
53895 size_t val2 ;
53896 int ecode2 = 0 ;
53897 PyObject * obj0 = 0 ;
53898 PyObject * obj1 = 0 ;
53899 char * kwnames[] = {
53900 (char *) "self",(char *) "idx", NULL
53901 };
53902
53903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53905 if (!SWIG_IsOK(res1)) {
53906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53907 }
53908 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53909 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53910 if (!SWIG_IsOK(ecode2)) {
53911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53912 }
53913 arg2 = static_cast< size_t >(val2);
53914 {
53915 PyThreadState* __tstate = wxPyBeginAllowThreads();
53916 (arg1)->RemoveGrowableRow(arg2);
53917 wxPyEndAllowThreads(__tstate);
53918 if (PyErr_Occurred()) SWIG_fail;
53919 }
53920 resultobj = SWIG_Py_Void();
53921 return resultobj;
53922 fail:
53923 return NULL;
53924 }
53925
53926
53927 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53928 PyObject *resultobj = 0;
53929 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53930 size_t arg2 ;
53931 int arg3 = (int) 0 ;
53932 void *argp1 = 0 ;
53933 int res1 = 0 ;
53934 size_t val2 ;
53935 int ecode2 = 0 ;
53936 int val3 ;
53937 int ecode3 = 0 ;
53938 PyObject * obj0 = 0 ;
53939 PyObject * obj1 = 0 ;
53940 PyObject * obj2 = 0 ;
53941 char * kwnames[] = {
53942 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53943 };
53944
53945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53947 if (!SWIG_IsOK(res1)) {
53948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53949 }
53950 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53951 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53952 if (!SWIG_IsOK(ecode2)) {
53953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53954 }
53955 arg2 = static_cast< size_t >(val2);
53956 if (obj2) {
53957 ecode3 = SWIG_AsVal_int(obj2, &val3);
53958 if (!SWIG_IsOK(ecode3)) {
53959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53960 }
53961 arg3 = static_cast< int >(val3);
53962 }
53963 {
53964 PyThreadState* __tstate = wxPyBeginAllowThreads();
53965 (arg1)->AddGrowableCol(arg2,arg3);
53966 wxPyEndAllowThreads(__tstate);
53967 if (PyErr_Occurred()) SWIG_fail;
53968 }
53969 resultobj = SWIG_Py_Void();
53970 return resultobj;
53971 fail:
53972 return NULL;
53973 }
53974
53975
53976 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53977 PyObject *resultobj = 0;
53978 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53979 size_t arg2 ;
53980 void *argp1 = 0 ;
53981 int res1 = 0 ;
53982 size_t val2 ;
53983 int ecode2 = 0 ;
53984 PyObject * obj0 = 0 ;
53985 PyObject * obj1 = 0 ;
53986 char * kwnames[] = {
53987 (char *) "self",(char *) "idx", NULL
53988 };
53989
53990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53992 if (!SWIG_IsOK(res1)) {
53993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53994 }
53995 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53996 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53997 if (!SWIG_IsOK(ecode2)) {
53998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53999 }
54000 arg2 = static_cast< size_t >(val2);
54001 {
54002 PyThreadState* __tstate = wxPyBeginAllowThreads();
54003 (arg1)->RemoveGrowableCol(arg2);
54004 wxPyEndAllowThreads(__tstate);
54005 if (PyErr_Occurred()) SWIG_fail;
54006 }
54007 resultobj = SWIG_Py_Void();
54008 return resultobj;
54009 fail:
54010 return NULL;
54011 }
54012
54013
54014 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54015 PyObject *resultobj = 0;
54016 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54017 int arg2 ;
54018 void *argp1 = 0 ;
54019 int res1 = 0 ;
54020 int val2 ;
54021 int ecode2 = 0 ;
54022 PyObject * obj0 = 0 ;
54023 PyObject * obj1 = 0 ;
54024 char * kwnames[] = {
54025 (char *) "self",(char *) "direction", NULL
54026 };
54027
54028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
54029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54030 if (!SWIG_IsOK(res1)) {
54031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54032 }
54033 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54034 ecode2 = SWIG_AsVal_int(obj1, &val2);
54035 if (!SWIG_IsOK(ecode2)) {
54036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
54037 }
54038 arg2 = static_cast< int >(val2);
54039 {
54040 PyThreadState* __tstate = wxPyBeginAllowThreads();
54041 (arg1)->SetFlexibleDirection(arg2);
54042 wxPyEndAllowThreads(__tstate);
54043 if (PyErr_Occurred()) SWIG_fail;
54044 }
54045 resultobj = SWIG_Py_Void();
54046 return resultobj;
54047 fail:
54048 return NULL;
54049 }
54050
54051
54052 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54053 PyObject *resultobj = 0;
54054 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54055 int result;
54056 void *argp1 = 0 ;
54057 int res1 = 0 ;
54058 PyObject *swig_obj[1] ;
54059
54060 if (!args) SWIG_fail;
54061 swig_obj[0] = args;
54062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54063 if (!SWIG_IsOK(res1)) {
54064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54065 }
54066 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54067 {
54068 PyThreadState* __tstate = wxPyBeginAllowThreads();
54069 result = (int)(arg1)->GetFlexibleDirection();
54070 wxPyEndAllowThreads(__tstate);
54071 if (PyErr_Occurred()) SWIG_fail;
54072 }
54073 resultobj = SWIG_From_int(static_cast< int >(result));
54074 return resultobj;
54075 fail:
54076 return NULL;
54077 }
54078
54079
54080 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54081 PyObject *resultobj = 0;
54082 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54083 wxFlexSizerGrowMode arg2 ;
54084 void *argp1 = 0 ;
54085 int res1 = 0 ;
54086 int val2 ;
54087 int ecode2 = 0 ;
54088 PyObject * obj0 = 0 ;
54089 PyObject * obj1 = 0 ;
54090 char * kwnames[] = {
54091 (char *) "self",(char *) "mode", NULL
54092 };
54093
54094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
54095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54096 if (!SWIG_IsOK(res1)) {
54097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54098 }
54099 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54100 ecode2 = SWIG_AsVal_int(obj1, &val2);
54101 if (!SWIG_IsOK(ecode2)) {
54102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
54103 }
54104 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
54105 {
54106 PyThreadState* __tstate = wxPyBeginAllowThreads();
54107 (arg1)->SetNonFlexibleGrowMode(arg2);
54108 wxPyEndAllowThreads(__tstate);
54109 if (PyErr_Occurred()) SWIG_fail;
54110 }
54111 resultobj = SWIG_Py_Void();
54112 return resultobj;
54113 fail:
54114 return NULL;
54115 }
54116
54117
54118 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54119 PyObject *resultobj = 0;
54120 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54121 wxFlexSizerGrowMode result;
54122 void *argp1 = 0 ;
54123 int res1 = 0 ;
54124 PyObject *swig_obj[1] ;
54125
54126 if (!args) SWIG_fail;
54127 swig_obj[0] = args;
54128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54129 if (!SWIG_IsOK(res1)) {
54130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54131 }
54132 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54133 {
54134 PyThreadState* __tstate = wxPyBeginAllowThreads();
54135 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
54136 wxPyEndAllowThreads(__tstate);
54137 if (PyErr_Occurred()) SWIG_fail;
54138 }
54139 resultobj = SWIG_From_int(static_cast< int >(result));
54140 return resultobj;
54141 fail:
54142 return NULL;
54143 }
54144
54145
54146 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54147 PyObject *resultobj = 0;
54148 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54149 wxArrayInt *result = 0 ;
54150 void *argp1 = 0 ;
54151 int res1 = 0 ;
54152 PyObject *swig_obj[1] ;
54153
54154 if (!args) SWIG_fail;
54155 swig_obj[0] = args;
54156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54157 if (!SWIG_IsOK(res1)) {
54158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54159 }
54160 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54161 {
54162 PyThreadState* __tstate = wxPyBeginAllowThreads();
54163 {
54164 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
54165 result = (wxArrayInt *) &_result_ref;
54166 }
54167 wxPyEndAllowThreads(__tstate);
54168 if (PyErr_Occurred()) SWIG_fail;
54169 }
54170 {
54171 resultobj = wxArrayInt2PyList_helper(*result);
54172 }
54173 return resultobj;
54174 fail:
54175 return NULL;
54176 }
54177
54178
54179 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54180 PyObject *resultobj = 0;
54181 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54182 wxArrayInt *result = 0 ;
54183 void *argp1 = 0 ;
54184 int res1 = 0 ;
54185 PyObject *swig_obj[1] ;
54186
54187 if (!args) SWIG_fail;
54188 swig_obj[0] = args;
54189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54190 if (!SWIG_IsOK(res1)) {
54191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54192 }
54193 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54194 {
54195 PyThreadState* __tstate = wxPyBeginAllowThreads();
54196 {
54197 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
54198 result = (wxArrayInt *) &_result_ref;
54199 }
54200 wxPyEndAllowThreads(__tstate);
54201 if (PyErr_Occurred()) SWIG_fail;
54202 }
54203 {
54204 resultobj = wxArrayInt2PyList_helper(*result);
54205 }
54206 return resultobj;
54207 fail:
54208 return NULL;
54209 }
54210
54211
54212 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54213 PyObject *obj;
54214 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54215 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
54216 return SWIG_Py_Void();
54217 }
54218
54219 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54220 return SWIG_Python_InitShadowInstance(args);
54221 }
54222
54223 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54224 PyObject *resultobj = 0;
54225 wxStdDialogButtonSizer *result = 0 ;
54226
54227 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
54228 {
54229 PyThreadState* __tstate = wxPyBeginAllowThreads();
54230 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
54231 wxPyEndAllowThreads(__tstate);
54232 if (PyErr_Occurred()) SWIG_fail;
54233 }
54234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
54235 return resultobj;
54236 fail:
54237 return NULL;
54238 }
54239
54240
54241 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54242 PyObject *resultobj = 0;
54243 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54244 wxButton *arg2 = (wxButton *) 0 ;
54245 void *argp1 = 0 ;
54246 int res1 = 0 ;
54247 void *argp2 = 0 ;
54248 int res2 = 0 ;
54249 PyObject * obj0 = 0 ;
54250 PyObject * obj1 = 0 ;
54251 char * kwnames[] = {
54252 (char *) "self",(char *) "button", NULL
54253 };
54254
54255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
54256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54257 if (!SWIG_IsOK(res1)) {
54258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54259 }
54260 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54262 if (!SWIG_IsOK(res2)) {
54263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
54264 }
54265 arg2 = reinterpret_cast< wxButton * >(argp2);
54266 {
54267 PyThreadState* __tstate = wxPyBeginAllowThreads();
54268 (arg1)->AddButton(arg2);
54269 wxPyEndAllowThreads(__tstate);
54270 if (PyErr_Occurred()) SWIG_fail;
54271 }
54272 resultobj = SWIG_Py_Void();
54273 return resultobj;
54274 fail:
54275 return NULL;
54276 }
54277
54278
54279 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54280 PyObject *resultobj = 0;
54281 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54282 void *argp1 = 0 ;
54283 int res1 = 0 ;
54284 PyObject *swig_obj[1] ;
54285
54286 if (!args) SWIG_fail;
54287 swig_obj[0] = args;
54288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54289 if (!SWIG_IsOK(res1)) {
54290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54291 }
54292 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54293 {
54294 PyThreadState* __tstate = wxPyBeginAllowThreads();
54295 (arg1)->Realize();
54296 wxPyEndAllowThreads(__tstate);
54297 if (PyErr_Occurred()) SWIG_fail;
54298 }
54299 resultobj = SWIG_Py_Void();
54300 return resultobj;
54301 fail:
54302 return NULL;
54303 }
54304
54305
54306 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54307 PyObject *resultobj = 0;
54308 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54309 wxButton *arg2 = (wxButton *) 0 ;
54310 void *argp1 = 0 ;
54311 int res1 = 0 ;
54312 void *argp2 = 0 ;
54313 int res2 = 0 ;
54314 PyObject * obj0 = 0 ;
54315 PyObject * obj1 = 0 ;
54316 char * kwnames[] = {
54317 (char *) "self",(char *) "button", NULL
54318 };
54319
54320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54322 if (!SWIG_IsOK(res1)) {
54323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54324 }
54325 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54327 if (!SWIG_IsOK(res2)) {
54328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54329 }
54330 arg2 = reinterpret_cast< wxButton * >(argp2);
54331 {
54332 PyThreadState* __tstate = wxPyBeginAllowThreads();
54333 (arg1)->SetAffirmativeButton(arg2);
54334 wxPyEndAllowThreads(__tstate);
54335 if (PyErr_Occurred()) SWIG_fail;
54336 }
54337 resultobj = SWIG_Py_Void();
54338 return resultobj;
54339 fail:
54340 return NULL;
54341 }
54342
54343
54344 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54345 PyObject *resultobj = 0;
54346 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54347 wxButton *arg2 = (wxButton *) 0 ;
54348 void *argp1 = 0 ;
54349 int res1 = 0 ;
54350 void *argp2 = 0 ;
54351 int res2 = 0 ;
54352 PyObject * obj0 = 0 ;
54353 PyObject * obj1 = 0 ;
54354 char * kwnames[] = {
54355 (char *) "self",(char *) "button", NULL
54356 };
54357
54358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54360 if (!SWIG_IsOK(res1)) {
54361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54362 }
54363 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54365 if (!SWIG_IsOK(res2)) {
54366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54367 }
54368 arg2 = reinterpret_cast< wxButton * >(argp2);
54369 {
54370 PyThreadState* __tstate = wxPyBeginAllowThreads();
54371 (arg1)->SetNegativeButton(arg2);
54372 wxPyEndAllowThreads(__tstate);
54373 if (PyErr_Occurred()) SWIG_fail;
54374 }
54375 resultobj = SWIG_Py_Void();
54376 return resultobj;
54377 fail:
54378 return NULL;
54379 }
54380
54381
54382 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54383 PyObject *resultobj = 0;
54384 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54385 wxButton *arg2 = (wxButton *) 0 ;
54386 void *argp1 = 0 ;
54387 int res1 = 0 ;
54388 void *argp2 = 0 ;
54389 int res2 = 0 ;
54390 PyObject * obj0 = 0 ;
54391 PyObject * obj1 = 0 ;
54392 char * kwnames[] = {
54393 (char *) "self",(char *) "button", NULL
54394 };
54395
54396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
54397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54398 if (!SWIG_IsOK(res1)) {
54399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54400 }
54401 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54403 if (!SWIG_IsOK(res2)) {
54404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
54405 }
54406 arg2 = reinterpret_cast< wxButton * >(argp2);
54407 {
54408 PyThreadState* __tstate = wxPyBeginAllowThreads();
54409 (arg1)->SetCancelButton(arg2);
54410 wxPyEndAllowThreads(__tstate);
54411 if (PyErr_Occurred()) SWIG_fail;
54412 }
54413 resultobj = SWIG_Py_Void();
54414 return resultobj;
54415 fail:
54416 return NULL;
54417 }
54418
54419
54420 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54421 PyObject *resultobj = 0;
54422 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54423 wxButton *result = 0 ;
54424 void *argp1 = 0 ;
54425 int res1 = 0 ;
54426 PyObject *swig_obj[1] ;
54427
54428 if (!args) SWIG_fail;
54429 swig_obj[0] = args;
54430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54431 if (!SWIG_IsOK(res1)) {
54432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54433 }
54434 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54435 {
54436 PyThreadState* __tstate = wxPyBeginAllowThreads();
54437 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
54438 wxPyEndAllowThreads(__tstate);
54439 if (PyErr_Occurred()) SWIG_fail;
54440 }
54441 {
54442 resultobj = wxPyMake_wxObject(result, (bool)0);
54443 }
54444 return resultobj;
54445 fail:
54446 return NULL;
54447 }
54448
54449
54450 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54451 PyObject *resultobj = 0;
54452 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54453 wxButton *result = 0 ;
54454 void *argp1 = 0 ;
54455 int res1 = 0 ;
54456 PyObject *swig_obj[1] ;
54457
54458 if (!args) SWIG_fail;
54459 swig_obj[0] = args;
54460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54461 if (!SWIG_IsOK(res1)) {
54462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54463 }
54464 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54465 {
54466 PyThreadState* __tstate = wxPyBeginAllowThreads();
54467 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
54468 wxPyEndAllowThreads(__tstate);
54469 if (PyErr_Occurred()) SWIG_fail;
54470 }
54471 {
54472 resultobj = wxPyMake_wxObject(result, (bool)0);
54473 }
54474 return resultobj;
54475 fail:
54476 return NULL;
54477 }
54478
54479
54480 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54481 PyObject *resultobj = 0;
54482 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54483 wxButton *result = 0 ;
54484 void *argp1 = 0 ;
54485 int res1 = 0 ;
54486 PyObject *swig_obj[1] ;
54487
54488 if (!args) SWIG_fail;
54489 swig_obj[0] = args;
54490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54491 if (!SWIG_IsOK(res1)) {
54492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54493 }
54494 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54495 {
54496 PyThreadState* __tstate = wxPyBeginAllowThreads();
54497 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
54498 wxPyEndAllowThreads(__tstate);
54499 if (PyErr_Occurred()) SWIG_fail;
54500 }
54501 {
54502 resultobj = wxPyMake_wxObject(result, (bool)0);
54503 }
54504 return resultobj;
54505 fail:
54506 return NULL;
54507 }
54508
54509
54510 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54511 PyObject *resultobj = 0;
54512 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54513 wxButton *result = 0 ;
54514 void *argp1 = 0 ;
54515 int res1 = 0 ;
54516 PyObject *swig_obj[1] ;
54517
54518 if (!args) SWIG_fail;
54519 swig_obj[0] = args;
54520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54521 if (!SWIG_IsOK(res1)) {
54522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54523 }
54524 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54525 {
54526 PyThreadState* __tstate = wxPyBeginAllowThreads();
54527 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
54528 wxPyEndAllowThreads(__tstate);
54529 if (PyErr_Occurred()) SWIG_fail;
54530 }
54531 {
54532 resultobj = wxPyMake_wxObject(result, (bool)0);
54533 }
54534 return resultobj;
54535 fail:
54536 return NULL;
54537 }
54538
54539
54540 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54541 PyObject *resultobj = 0;
54542 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54543 wxButton *result = 0 ;
54544 void *argp1 = 0 ;
54545 int res1 = 0 ;
54546 PyObject *swig_obj[1] ;
54547
54548 if (!args) SWIG_fail;
54549 swig_obj[0] = args;
54550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54551 if (!SWIG_IsOK(res1)) {
54552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54553 }
54554 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54555 {
54556 PyThreadState* __tstate = wxPyBeginAllowThreads();
54557 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
54558 wxPyEndAllowThreads(__tstate);
54559 if (PyErr_Occurred()) SWIG_fail;
54560 }
54561 {
54562 resultobj = wxPyMake_wxObject(result, (bool)0);
54563 }
54564 return resultobj;
54565 fail:
54566 return NULL;
54567 }
54568
54569
54570 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54571 PyObject *obj;
54572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54573 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
54574 return SWIG_Py_Void();
54575 }
54576
54577 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54578 return SWIG_Python_InitShadowInstance(args);
54579 }
54580
54581 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54582 PyObject *resultobj = 0;
54583 int arg1 = (int) 0 ;
54584 int arg2 = (int) 0 ;
54585 wxGBPosition *result = 0 ;
54586 int val1 ;
54587 int ecode1 = 0 ;
54588 int val2 ;
54589 int ecode2 = 0 ;
54590 PyObject * obj0 = 0 ;
54591 PyObject * obj1 = 0 ;
54592 char * kwnames[] = {
54593 (char *) "row",(char *) "col", NULL
54594 };
54595
54596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54597 if (obj0) {
54598 ecode1 = SWIG_AsVal_int(obj0, &val1);
54599 if (!SWIG_IsOK(ecode1)) {
54600 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
54601 }
54602 arg1 = static_cast< int >(val1);
54603 }
54604 if (obj1) {
54605 ecode2 = SWIG_AsVal_int(obj1, &val2);
54606 if (!SWIG_IsOK(ecode2)) {
54607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
54608 }
54609 arg2 = static_cast< int >(val2);
54610 }
54611 {
54612 PyThreadState* __tstate = wxPyBeginAllowThreads();
54613 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
54614 wxPyEndAllowThreads(__tstate);
54615 if (PyErr_Occurred()) SWIG_fail;
54616 }
54617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
54618 return resultobj;
54619 fail:
54620 return NULL;
54621 }
54622
54623
54624 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54625 PyObject *resultobj = 0;
54626 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54627 void *argp1 = 0 ;
54628 int res1 = 0 ;
54629 PyObject *swig_obj[1] ;
54630
54631 if (!args) SWIG_fail;
54632 swig_obj[0] = args;
54633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
54634 if (!SWIG_IsOK(res1)) {
54635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54636 }
54637 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54638 {
54639 PyThreadState* __tstate = wxPyBeginAllowThreads();
54640 delete arg1;
54641
54642 wxPyEndAllowThreads(__tstate);
54643 if (PyErr_Occurred()) SWIG_fail;
54644 }
54645 resultobj = SWIG_Py_Void();
54646 return resultobj;
54647 fail:
54648 return NULL;
54649 }
54650
54651
54652 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54653 PyObject *resultobj = 0;
54654 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54655 int result;
54656 void *argp1 = 0 ;
54657 int res1 = 0 ;
54658 PyObject *swig_obj[1] ;
54659
54660 if (!args) SWIG_fail;
54661 swig_obj[0] = args;
54662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54663 if (!SWIG_IsOK(res1)) {
54664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54665 }
54666 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54667 {
54668 PyThreadState* __tstate = wxPyBeginAllowThreads();
54669 result = (int)((wxGBPosition const *)arg1)->GetRow();
54670 wxPyEndAllowThreads(__tstate);
54671 if (PyErr_Occurred()) SWIG_fail;
54672 }
54673 resultobj = SWIG_From_int(static_cast< int >(result));
54674 return resultobj;
54675 fail:
54676 return NULL;
54677 }
54678
54679
54680 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54681 PyObject *resultobj = 0;
54682 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54683 int result;
54684 void *argp1 = 0 ;
54685 int res1 = 0 ;
54686 PyObject *swig_obj[1] ;
54687
54688 if (!args) SWIG_fail;
54689 swig_obj[0] = args;
54690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54691 if (!SWIG_IsOK(res1)) {
54692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54693 }
54694 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54695 {
54696 PyThreadState* __tstate = wxPyBeginAllowThreads();
54697 result = (int)((wxGBPosition const *)arg1)->GetCol();
54698 wxPyEndAllowThreads(__tstate);
54699 if (PyErr_Occurred()) SWIG_fail;
54700 }
54701 resultobj = SWIG_From_int(static_cast< int >(result));
54702 return resultobj;
54703 fail:
54704 return NULL;
54705 }
54706
54707
54708 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54709 PyObject *resultobj = 0;
54710 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54711 int arg2 ;
54712 void *argp1 = 0 ;
54713 int res1 = 0 ;
54714 int val2 ;
54715 int ecode2 = 0 ;
54716 PyObject * obj0 = 0 ;
54717 PyObject * obj1 = 0 ;
54718 char * kwnames[] = {
54719 (char *) "self",(char *) "row", NULL
54720 };
54721
54722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
54723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54724 if (!SWIG_IsOK(res1)) {
54725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54726 }
54727 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54728 ecode2 = SWIG_AsVal_int(obj1, &val2);
54729 if (!SWIG_IsOK(ecode2)) {
54730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54731 }
54732 arg2 = static_cast< int >(val2);
54733 {
54734 PyThreadState* __tstate = wxPyBeginAllowThreads();
54735 (arg1)->SetRow(arg2);
54736 wxPyEndAllowThreads(__tstate);
54737 if (PyErr_Occurred()) SWIG_fail;
54738 }
54739 resultobj = SWIG_Py_Void();
54740 return resultobj;
54741 fail:
54742 return NULL;
54743 }
54744
54745
54746 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54747 PyObject *resultobj = 0;
54748 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54749 int arg2 ;
54750 void *argp1 = 0 ;
54751 int res1 = 0 ;
54752 int val2 ;
54753 int ecode2 = 0 ;
54754 PyObject * obj0 = 0 ;
54755 PyObject * obj1 = 0 ;
54756 char * kwnames[] = {
54757 (char *) "self",(char *) "col", NULL
54758 };
54759
54760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54762 if (!SWIG_IsOK(res1)) {
54763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54764 }
54765 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54766 ecode2 = SWIG_AsVal_int(obj1, &val2);
54767 if (!SWIG_IsOK(ecode2)) {
54768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54769 }
54770 arg2 = static_cast< int >(val2);
54771 {
54772 PyThreadState* __tstate = wxPyBeginAllowThreads();
54773 (arg1)->SetCol(arg2);
54774 wxPyEndAllowThreads(__tstate);
54775 if (PyErr_Occurred()) SWIG_fail;
54776 }
54777 resultobj = SWIG_Py_Void();
54778 return resultobj;
54779 fail:
54780 return NULL;
54781 }
54782
54783
54784 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54785 PyObject *resultobj = 0;
54786 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54787 PyObject *arg2 = (PyObject *) 0 ;
54788 bool result;
54789 void *argp1 = 0 ;
54790 int res1 = 0 ;
54791 PyObject * obj0 = 0 ;
54792 PyObject * obj1 = 0 ;
54793 char * kwnames[] = {
54794 (char *) "self",(char *) "other", NULL
54795 };
54796
54797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54799 if (!SWIG_IsOK(res1)) {
54800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54801 }
54802 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54803 arg2 = obj1;
54804 {
54805 result = (bool)wxGBPosition___eq__(arg1,arg2);
54806 if (PyErr_Occurred()) SWIG_fail;
54807 }
54808 {
54809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54810 }
54811 return resultobj;
54812 fail:
54813 return NULL;
54814 }
54815
54816
54817 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54818 PyObject *resultobj = 0;
54819 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54820 PyObject *arg2 = (PyObject *) 0 ;
54821 bool result;
54822 void *argp1 = 0 ;
54823 int res1 = 0 ;
54824 PyObject * obj0 = 0 ;
54825 PyObject * obj1 = 0 ;
54826 char * kwnames[] = {
54827 (char *) "self",(char *) "other", NULL
54828 };
54829
54830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54832 if (!SWIG_IsOK(res1)) {
54833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54834 }
54835 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54836 arg2 = obj1;
54837 {
54838 result = (bool)wxGBPosition___ne__(arg1,arg2);
54839 if (PyErr_Occurred()) SWIG_fail;
54840 }
54841 {
54842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54843 }
54844 return resultobj;
54845 fail:
54846 return NULL;
54847 }
54848
54849
54850 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54851 PyObject *resultobj = 0;
54852 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54853 int arg2 = (int) 0 ;
54854 int arg3 = (int) 0 ;
54855 void *argp1 = 0 ;
54856 int res1 = 0 ;
54857 int val2 ;
54858 int ecode2 = 0 ;
54859 int val3 ;
54860 int ecode3 = 0 ;
54861 PyObject * obj0 = 0 ;
54862 PyObject * obj1 = 0 ;
54863 PyObject * obj2 = 0 ;
54864 char * kwnames[] = {
54865 (char *) "self",(char *) "row",(char *) "col", NULL
54866 };
54867
54868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54870 if (!SWIG_IsOK(res1)) {
54871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54872 }
54873 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54874 if (obj1) {
54875 ecode2 = SWIG_AsVal_int(obj1, &val2);
54876 if (!SWIG_IsOK(ecode2)) {
54877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54878 }
54879 arg2 = static_cast< int >(val2);
54880 }
54881 if (obj2) {
54882 ecode3 = SWIG_AsVal_int(obj2, &val3);
54883 if (!SWIG_IsOK(ecode3)) {
54884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54885 }
54886 arg3 = static_cast< int >(val3);
54887 }
54888 {
54889 PyThreadState* __tstate = wxPyBeginAllowThreads();
54890 wxGBPosition_Set(arg1,arg2,arg3);
54891 wxPyEndAllowThreads(__tstate);
54892 if (PyErr_Occurred()) SWIG_fail;
54893 }
54894 resultobj = SWIG_Py_Void();
54895 return resultobj;
54896 fail:
54897 return NULL;
54898 }
54899
54900
54901 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54902 PyObject *resultobj = 0;
54903 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54904 PyObject *result = 0 ;
54905 void *argp1 = 0 ;
54906 int res1 = 0 ;
54907 PyObject *swig_obj[1] ;
54908
54909 if (!args) SWIG_fail;
54910 swig_obj[0] = args;
54911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54912 if (!SWIG_IsOK(res1)) {
54913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54914 }
54915 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54916 {
54917 PyThreadState* __tstate = wxPyBeginAllowThreads();
54918 result = (PyObject *)wxGBPosition_Get(arg1);
54919 wxPyEndAllowThreads(__tstate);
54920 if (PyErr_Occurred()) SWIG_fail;
54921 }
54922 resultobj = result;
54923 return resultobj;
54924 fail:
54925 return NULL;
54926 }
54927
54928
54929 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54930 PyObject *obj;
54931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54932 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54933 return SWIG_Py_Void();
54934 }
54935
54936 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54937 return SWIG_Python_InitShadowInstance(args);
54938 }
54939
54940 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54941 PyObject *resultobj = 0;
54942 int arg1 = (int) 1 ;
54943 int arg2 = (int) 1 ;
54944 wxGBSpan *result = 0 ;
54945 int val1 ;
54946 int ecode1 = 0 ;
54947 int val2 ;
54948 int ecode2 = 0 ;
54949 PyObject * obj0 = 0 ;
54950 PyObject * obj1 = 0 ;
54951 char * kwnames[] = {
54952 (char *) "rowspan",(char *) "colspan", NULL
54953 };
54954
54955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54956 if (obj0) {
54957 ecode1 = SWIG_AsVal_int(obj0, &val1);
54958 if (!SWIG_IsOK(ecode1)) {
54959 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54960 }
54961 arg1 = static_cast< int >(val1);
54962 }
54963 if (obj1) {
54964 ecode2 = SWIG_AsVal_int(obj1, &val2);
54965 if (!SWIG_IsOK(ecode2)) {
54966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54967 }
54968 arg2 = static_cast< int >(val2);
54969 }
54970 {
54971 PyThreadState* __tstate = wxPyBeginAllowThreads();
54972 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54973 wxPyEndAllowThreads(__tstate);
54974 if (PyErr_Occurred()) SWIG_fail;
54975 }
54976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54977 return resultobj;
54978 fail:
54979 return NULL;
54980 }
54981
54982
54983 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54984 PyObject *resultobj = 0;
54985 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54986 void *argp1 = 0 ;
54987 int res1 = 0 ;
54988 PyObject *swig_obj[1] ;
54989
54990 if (!args) SWIG_fail;
54991 swig_obj[0] = args;
54992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54993 if (!SWIG_IsOK(res1)) {
54994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54995 }
54996 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54997 {
54998 PyThreadState* __tstate = wxPyBeginAllowThreads();
54999 delete arg1;
55000
55001 wxPyEndAllowThreads(__tstate);
55002 if (PyErr_Occurred()) SWIG_fail;
55003 }
55004 resultobj = SWIG_Py_Void();
55005 return resultobj;
55006 fail:
55007 return NULL;
55008 }
55009
55010
55011 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55012 PyObject *resultobj = 0;
55013 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55014 int result;
55015 void *argp1 = 0 ;
55016 int res1 = 0 ;
55017 PyObject *swig_obj[1] ;
55018
55019 if (!args) SWIG_fail;
55020 swig_obj[0] = args;
55021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55022 if (!SWIG_IsOK(res1)) {
55023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
55024 }
55025 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55026 {
55027 PyThreadState* __tstate = wxPyBeginAllowThreads();
55028 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
55029 wxPyEndAllowThreads(__tstate);
55030 if (PyErr_Occurred()) SWIG_fail;
55031 }
55032 resultobj = SWIG_From_int(static_cast< int >(result));
55033 return resultobj;
55034 fail:
55035 return NULL;
55036 }
55037
55038
55039 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55040 PyObject *resultobj = 0;
55041 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55042 int result;
55043 void *argp1 = 0 ;
55044 int res1 = 0 ;
55045 PyObject *swig_obj[1] ;
55046
55047 if (!args) SWIG_fail;
55048 swig_obj[0] = args;
55049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55050 if (!SWIG_IsOK(res1)) {
55051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
55052 }
55053 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55054 {
55055 PyThreadState* __tstate = wxPyBeginAllowThreads();
55056 result = (int)((wxGBSpan const *)arg1)->GetColspan();
55057 wxPyEndAllowThreads(__tstate);
55058 if (PyErr_Occurred()) SWIG_fail;
55059 }
55060 resultobj = SWIG_From_int(static_cast< int >(result));
55061 return resultobj;
55062 fail:
55063 return NULL;
55064 }
55065
55066
55067 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55068 PyObject *resultobj = 0;
55069 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55070 int arg2 ;
55071 void *argp1 = 0 ;
55072 int res1 = 0 ;
55073 int val2 ;
55074 int ecode2 = 0 ;
55075 PyObject * obj0 = 0 ;
55076 PyObject * obj1 = 0 ;
55077 char * kwnames[] = {
55078 (char *) "self",(char *) "rowspan", NULL
55079 };
55080
55081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
55082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55083 if (!SWIG_IsOK(res1)) {
55084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55085 }
55086 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55087 ecode2 = SWIG_AsVal_int(obj1, &val2);
55088 if (!SWIG_IsOK(ecode2)) {
55089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
55090 }
55091 arg2 = static_cast< int >(val2);
55092 {
55093 PyThreadState* __tstate = wxPyBeginAllowThreads();
55094 (arg1)->SetRowspan(arg2);
55095 wxPyEndAllowThreads(__tstate);
55096 if (PyErr_Occurred()) SWIG_fail;
55097 }
55098 resultobj = SWIG_Py_Void();
55099 return resultobj;
55100 fail:
55101 return NULL;
55102 }
55103
55104
55105 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55106 PyObject *resultobj = 0;
55107 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55108 int arg2 ;
55109 void *argp1 = 0 ;
55110 int res1 = 0 ;
55111 int val2 ;
55112 int ecode2 = 0 ;
55113 PyObject * obj0 = 0 ;
55114 PyObject * obj1 = 0 ;
55115 char * kwnames[] = {
55116 (char *) "self",(char *) "colspan", NULL
55117 };
55118
55119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
55120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55121 if (!SWIG_IsOK(res1)) {
55122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55123 }
55124 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55125 ecode2 = SWIG_AsVal_int(obj1, &val2);
55126 if (!SWIG_IsOK(ecode2)) {
55127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
55128 }
55129 arg2 = static_cast< int >(val2);
55130 {
55131 PyThreadState* __tstate = wxPyBeginAllowThreads();
55132 (arg1)->SetColspan(arg2);
55133 wxPyEndAllowThreads(__tstate);
55134 if (PyErr_Occurred()) SWIG_fail;
55135 }
55136 resultobj = SWIG_Py_Void();
55137 return resultobj;
55138 fail:
55139 return NULL;
55140 }
55141
55142
55143 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55144 PyObject *resultobj = 0;
55145 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55146 PyObject *arg2 = (PyObject *) 0 ;
55147 bool result;
55148 void *argp1 = 0 ;
55149 int res1 = 0 ;
55150 PyObject * obj0 = 0 ;
55151 PyObject * obj1 = 0 ;
55152 char * kwnames[] = {
55153 (char *) "self",(char *) "other", NULL
55154 };
55155
55156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
55157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55158 if (!SWIG_IsOK(res1)) {
55159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55160 }
55161 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55162 arg2 = obj1;
55163 {
55164 result = (bool)wxGBSpan___eq__(arg1,arg2);
55165 if (PyErr_Occurred()) SWIG_fail;
55166 }
55167 {
55168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55169 }
55170 return resultobj;
55171 fail:
55172 return NULL;
55173 }
55174
55175
55176 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55177 PyObject *resultobj = 0;
55178 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55179 PyObject *arg2 = (PyObject *) 0 ;
55180 bool result;
55181 void *argp1 = 0 ;
55182 int res1 = 0 ;
55183 PyObject * obj0 = 0 ;
55184 PyObject * obj1 = 0 ;
55185 char * kwnames[] = {
55186 (char *) "self",(char *) "other", NULL
55187 };
55188
55189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
55190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55191 if (!SWIG_IsOK(res1)) {
55192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55193 }
55194 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55195 arg2 = obj1;
55196 {
55197 result = (bool)wxGBSpan___ne__(arg1,arg2);
55198 if (PyErr_Occurred()) SWIG_fail;
55199 }
55200 {
55201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55202 }
55203 return resultobj;
55204 fail:
55205 return NULL;
55206 }
55207
55208
55209 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55210 PyObject *resultobj = 0;
55211 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55212 int arg2 = (int) 1 ;
55213 int arg3 = (int) 1 ;
55214 void *argp1 = 0 ;
55215 int res1 = 0 ;
55216 int val2 ;
55217 int ecode2 = 0 ;
55218 int val3 ;
55219 int ecode3 = 0 ;
55220 PyObject * obj0 = 0 ;
55221 PyObject * obj1 = 0 ;
55222 PyObject * obj2 = 0 ;
55223 char * kwnames[] = {
55224 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
55225 };
55226
55227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55229 if (!SWIG_IsOK(res1)) {
55230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55231 }
55232 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55233 if (obj1) {
55234 ecode2 = SWIG_AsVal_int(obj1, &val2);
55235 if (!SWIG_IsOK(ecode2)) {
55236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
55237 }
55238 arg2 = static_cast< int >(val2);
55239 }
55240 if (obj2) {
55241 ecode3 = SWIG_AsVal_int(obj2, &val3);
55242 if (!SWIG_IsOK(ecode3)) {
55243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
55244 }
55245 arg3 = static_cast< int >(val3);
55246 }
55247 {
55248 PyThreadState* __tstate = wxPyBeginAllowThreads();
55249 wxGBSpan_Set(arg1,arg2,arg3);
55250 wxPyEndAllowThreads(__tstate);
55251 if (PyErr_Occurred()) SWIG_fail;
55252 }
55253 resultobj = SWIG_Py_Void();
55254 return resultobj;
55255 fail:
55256 return NULL;
55257 }
55258
55259
55260 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55261 PyObject *resultobj = 0;
55262 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55263 PyObject *result = 0 ;
55264 void *argp1 = 0 ;
55265 int res1 = 0 ;
55266 PyObject *swig_obj[1] ;
55267
55268 if (!args) SWIG_fail;
55269 swig_obj[0] = args;
55270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55271 if (!SWIG_IsOK(res1)) {
55272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55273 }
55274 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55275 {
55276 PyThreadState* __tstate = wxPyBeginAllowThreads();
55277 result = (PyObject *)wxGBSpan_Get(arg1);
55278 wxPyEndAllowThreads(__tstate);
55279 if (PyErr_Occurred()) SWIG_fail;
55280 }
55281 resultobj = result;
55282 return resultobj;
55283 fail:
55284 return NULL;
55285 }
55286
55287
55288 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55289 PyObject *obj;
55290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55291 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
55292 return SWIG_Py_Void();
55293 }
55294
55295 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55296 return SWIG_Python_InitShadowInstance(args);
55297 }
55298
55299 SWIGINTERN int DefaultSpan_set(PyObject *) {
55300 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
55301 return 1;
55302 }
55303
55304
55305 SWIGINTERN PyObject *DefaultSpan_get(void) {
55306 PyObject *pyobj = 0;
55307
55308 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
55309 return pyobj;
55310 }
55311
55312
55313 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55314 PyObject *resultobj = 0;
55315 wxGBSizerItem *result = 0 ;
55316
55317 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
55318 {
55319 PyThreadState* __tstate = wxPyBeginAllowThreads();
55320 result = (wxGBSizerItem *)new wxGBSizerItem();
55321 wxPyEndAllowThreads(__tstate);
55322 if (PyErr_Occurred()) SWIG_fail;
55323 }
55324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
55325 return resultobj;
55326 fail:
55327 return NULL;
55328 }
55329
55330
55331 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55332 PyObject *resultobj = 0;
55333 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55334 void *argp1 = 0 ;
55335 int res1 = 0 ;
55336 PyObject *swig_obj[1] ;
55337
55338 if (!args) SWIG_fail;
55339 swig_obj[0] = args;
55340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55341 if (!SWIG_IsOK(res1)) {
55342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55343 }
55344 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55345 {
55346 PyThreadState* __tstate = wxPyBeginAllowThreads();
55347 delete arg1;
55348
55349 wxPyEndAllowThreads(__tstate);
55350 if (PyErr_Occurred()) SWIG_fail;
55351 }
55352 resultobj = SWIG_Py_Void();
55353 return resultobj;
55354 fail:
55355 return NULL;
55356 }
55357
55358
55359 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55360 PyObject *resultobj = 0;
55361 wxWindow *arg1 = (wxWindow *) 0 ;
55362 wxGBPosition *arg2 = 0 ;
55363 wxGBSpan *arg3 = 0 ;
55364 int arg4 ;
55365 int arg5 ;
55366 PyObject *arg6 = (PyObject *) NULL ;
55367 wxGBSizerItem *result = 0 ;
55368 void *argp1 = 0 ;
55369 int res1 = 0 ;
55370 wxGBPosition temp2 ;
55371 wxGBSpan temp3 ;
55372 int val4 ;
55373 int ecode4 = 0 ;
55374 int val5 ;
55375 int ecode5 = 0 ;
55376 PyObject * obj0 = 0 ;
55377 PyObject * obj1 = 0 ;
55378 PyObject * obj2 = 0 ;
55379 PyObject * obj3 = 0 ;
55380 PyObject * obj4 = 0 ;
55381 PyObject * obj5 = 0 ;
55382 char * kwnames[] = {
55383 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55384 };
55385
55386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
55388 if (!SWIG_IsOK(res1)) {
55389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
55390 }
55391 arg1 = reinterpret_cast< wxWindow * >(argp1);
55392 {
55393 arg2 = &temp2;
55394 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55395 }
55396 {
55397 arg3 = &temp3;
55398 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55399 }
55400 ecode4 = SWIG_AsVal_int(obj3, &val4);
55401 if (!SWIG_IsOK(ecode4)) {
55402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
55403 }
55404 arg4 = static_cast< int >(val4);
55405 ecode5 = SWIG_AsVal_int(obj4, &val5);
55406 if (!SWIG_IsOK(ecode5)) {
55407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
55408 }
55409 arg5 = static_cast< int >(val5);
55410 if (obj5) {
55411 arg6 = obj5;
55412 }
55413 {
55414 PyThreadState* __tstate = wxPyBeginAllowThreads();
55415 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55416 wxPyEndAllowThreads(__tstate);
55417 if (PyErr_Occurred()) SWIG_fail;
55418 }
55419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55420 return resultobj;
55421 fail:
55422 return NULL;
55423 }
55424
55425
55426 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55427 PyObject *resultobj = 0;
55428 wxSizer *arg1 = (wxSizer *) 0 ;
55429 wxGBPosition *arg2 = 0 ;
55430 wxGBSpan *arg3 = 0 ;
55431 int arg4 ;
55432 int arg5 ;
55433 PyObject *arg6 = (PyObject *) NULL ;
55434 wxGBSizerItem *result = 0 ;
55435 int res1 = 0 ;
55436 wxGBPosition temp2 ;
55437 wxGBSpan temp3 ;
55438 int val4 ;
55439 int ecode4 = 0 ;
55440 int val5 ;
55441 int ecode5 = 0 ;
55442 PyObject * obj0 = 0 ;
55443 PyObject * obj1 = 0 ;
55444 PyObject * obj2 = 0 ;
55445 PyObject * obj3 = 0 ;
55446 PyObject * obj4 = 0 ;
55447 PyObject * obj5 = 0 ;
55448 char * kwnames[] = {
55449 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55450 };
55451
55452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55453 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
55454 if (!SWIG_IsOK(res1)) {
55455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
55456 }
55457 {
55458 arg2 = &temp2;
55459 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55460 }
55461 {
55462 arg3 = &temp3;
55463 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55464 }
55465 ecode4 = SWIG_AsVal_int(obj3, &val4);
55466 if (!SWIG_IsOK(ecode4)) {
55467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
55468 }
55469 arg4 = static_cast< int >(val4);
55470 ecode5 = SWIG_AsVal_int(obj4, &val5);
55471 if (!SWIG_IsOK(ecode5)) {
55472 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
55473 }
55474 arg5 = static_cast< int >(val5);
55475 if (obj5) {
55476 arg6 = obj5;
55477 }
55478 {
55479 PyThreadState* __tstate = wxPyBeginAllowThreads();
55480 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55481 wxPyEndAllowThreads(__tstate);
55482 if (PyErr_Occurred()) SWIG_fail;
55483 }
55484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55485 return resultobj;
55486 fail:
55487 return NULL;
55488 }
55489
55490
55491 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55492 PyObject *resultobj = 0;
55493 int arg1 ;
55494 int arg2 ;
55495 wxGBPosition *arg3 = 0 ;
55496 wxGBSpan *arg4 = 0 ;
55497 int arg5 ;
55498 int arg6 ;
55499 PyObject *arg7 = (PyObject *) NULL ;
55500 wxGBSizerItem *result = 0 ;
55501 int val1 ;
55502 int ecode1 = 0 ;
55503 int val2 ;
55504 int ecode2 = 0 ;
55505 wxGBPosition temp3 ;
55506 wxGBSpan temp4 ;
55507 int val5 ;
55508 int ecode5 = 0 ;
55509 int val6 ;
55510 int ecode6 = 0 ;
55511 PyObject * obj0 = 0 ;
55512 PyObject * obj1 = 0 ;
55513 PyObject * obj2 = 0 ;
55514 PyObject * obj3 = 0 ;
55515 PyObject * obj4 = 0 ;
55516 PyObject * obj5 = 0 ;
55517 PyObject * obj6 = 0 ;
55518 char * kwnames[] = {
55519 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55520 };
55521
55522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55523 ecode1 = SWIG_AsVal_int(obj0, &val1);
55524 if (!SWIG_IsOK(ecode1)) {
55525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
55526 }
55527 arg1 = static_cast< int >(val1);
55528 ecode2 = SWIG_AsVal_int(obj1, &val2);
55529 if (!SWIG_IsOK(ecode2)) {
55530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
55531 }
55532 arg2 = static_cast< int >(val2);
55533 {
55534 arg3 = &temp3;
55535 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55536 }
55537 {
55538 arg4 = &temp4;
55539 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55540 }
55541 ecode5 = SWIG_AsVal_int(obj4, &val5);
55542 if (!SWIG_IsOK(ecode5)) {
55543 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
55544 }
55545 arg5 = static_cast< int >(val5);
55546 ecode6 = SWIG_AsVal_int(obj5, &val6);
55547 if (!SWIG_IsOK(ecode6)) {
55548 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
55549 }
55550 arg6 = static_cast< int >(val6);
55551 if (obj6) {
55552 arg7 = obj6;
55553 }
55554 {
55555 PyThreadState* __tstate = wxPyBeginAllowThreads();
55556 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55557 wxPyEndAllowThreads(__tstate);
55558 if (PyErr_Occurred()) SWIG_fail;
55559 }
55560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55561 return resultobj;
55562 fail:
55563 return NULL;
55564 }
55565
55566
55567 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55568 PyObject *resultobj = 0;
55569 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55570 wxGBPosition result;
55571 void *argp1 = 0 ;
55572 int res1 = 0 ;
55573 PyObject *swig_obj[1] ;
55574
55575 if (!args) SWIG_fail;
55576 swig_obj[0] = args;
55577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55578 if (!SWIG_IsOK(res1)) {
55579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55580 }
55581 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55582 {
55583 PyThreadState* __tstate = wxPyBeginAllowThreads();
55584 result = ((wxGBSizerItem const *)arg1)->GetPos();
55585 wxPyEndAllowThreads(__tstate);
55586 if (PyErr_Occurred()) SWIG_fail;
55587 }
55588 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55589 return resultobj;
55590 fail:
55591 return NULL;
55592 }
55593
55594
55595 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55596 PyObject *resultobj = 0;
55597 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55598 wxGBSpan result;
55599 void *argp1 = 0 ;
55600 int res1 = 0 ;
55601 PyObject *swig_obj[1] ;
55602
55603 if (!args) SWIG_fail;
55604 swig_obj[0] = args;
55605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55606 if (!SWIG_IsOK(res1)) {
55607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55608 }
55609 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55610 {
55611 PyThreadState* __tstate = wxPyBeginAllowThreads();
55612 result = ((wxGBSizerItem const *)arg1)->GetSpan();
55613 wxPyEndAllowThreads(__tstate);
55614 if (PyErr_Occurred()) SWIG_fail;
55615 }
55616 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55617 return resultobj;
55618 fail:
55619 return NULL;
55620 }
55621
55622
55623 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55624 PyObject *resultobj = 0;
55625 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55626 wxGBPosition *arg2 = 0 ;
55627 bool result;
55628 void *argp1 = 0 ;
55629 int res1 = 0 ;
55630 wxGBPosition temp2 ;
55631 PyObject * obj0 = 0 ;
55632 PyObject * obj1 = 0 ;
55633 char * kwnames[] = {
55634 (char *) "self",(char *) "pos", NULL
55635 };
55636
55637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
55638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55639 if (!SWIG_IsOK(res1)) {
55640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55641 }
55642 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55643 {
55644 arg2 = &temp2;
55645 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55646 }
55647 {
55648 PyThreadState* __tstate = wxPyBeginAllowThreads();
55649 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
55650 wxPyEndAllowThreads(__tstate);
55651 if (PyErr_Occurred()) SWIG_fail;
55652 }
55653 {
55654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55655 }
55656 return resultobj;
55657 fail:
55658 return NULL;
55659 }
55660
55661
55662 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55663 PyObject *resultobj = 0;
55664 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55665 wxGBSpan *arg2 = 0 ;
55666 bool result;
55667 void *argp1 = 0 ;
55668 int res1 = 0 ;
55669 wxGBSpan temp2 ;
55670 PyObject * obj0 = 0 ;
55671 PyObject * obj1 = 0 ;
55672 char * kwnames[] = {
55673 (char *) "self",(char *) "span", NULL
55674 };
55675
55676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
55677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55678 if (!SWIG_IsOK(res1)) {
55679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55680 }
55681 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55682 {
55683 arg2 = &temp2;
55684 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
55685 }
55686 {
55687 PyThreadState* __tstate = wxPyBeginAllowThreads();
55688 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
55689 wxPyEndAllowThreads(__tstate);
55690 if (PyErr_Occurred()) SWIG_fail;
55691 }
55692 {
55693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55694 }
55695 return resultobj;
55696 fail:
55697 return NULL;
55698 }
55699
55700
55701 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55702 PyObject *resultobj = 0;
55703 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55704 wxGBSizerItem *arg2 = 0 ;
55705 bool result;
55706 void *argp1 = 0 ;
55707 int res1 = 0 ;
55708 void *argp2 = 0 ;
55709 int res2 = 0 ;
55710 PyObject * obj0 = 0 ;
55711 PyObject * obj1 = 0 ;
55712 char * kwnames[] = {
55713 (char *) "self",(char *) "other", NULL
55714 };
55715
55716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
55717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55718 if (!SWIG_IsOK(res1)) {
55719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55720 }
55721 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55722 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
55723 if (!SWIG_IsOK(res2)) {
55724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55725 }
55726 if (!argp2) {
55727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55728 }
55729 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55730 {
55731 PyThreadState* __tstate = wxPyBeginAllowThreads();
55732 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55733 wxPyEndAllowThreads(__tstate);
55734 if (PyErr_Occurred()) SWIG_fail;
55735 }
55736 {
55737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55738 }
55739 return resultobj;
55740 fail:
55741 return NULL;
55742 }
55743
55744
55745 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55746 PyObject *resultobj = 0;
55747 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55748 wxGBPosition *arg2 = 0 ;
55749 wxGBSpan *arg3 = 0 ;
55750 bool result;
55751 void *argp1 = 0 ;
55752 int res1 = 0 ;
55753 wxGBPosition temp2 ;
55754 wxGBSpan temp3 ;
55755 PyObject * obj0 = 0 ;
55756 PyObject * obj1 = 0 ;
55757 PyObject * obj2 = 0 ;
55758 char * kwnames[] = {
55759 (char *) "self",(char *) "pos",(char *) "span", NULL
55760 };
55761
55762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55764 if (!SWIG_IsOK(res1)) {
55765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55766 }
55767 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55768 {
55769 arg2 = &temp2;
55770 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55771 }
55772 {
55773 arg3 = &temp3;
55774 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55775 }
55776 {
55777 PyThreadState* __tstate = wxPyBeginAllowThreads();
55778 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55779 wxPyEndAllowThreads(__tstate);
55780 if (PyErr_Occurred()) SWIG_fail;
55781 }
55782 {
55783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55784 }
55785 return resultobj;
55786 fail:
55787 return NULL;
55788 }
55789
55790
55791 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55792 PyObject *resultobj = 0;
55793 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55794 wxGBPosition result;
55795 void *argp1 = 0 ;
55796 int res1 = 0 ;
55797 PyObject *swig_obj[1] ;
55798
55799 if (!args) SWIG_fail;
55800 swig_obj[0] = args;
55801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55802 if (!SWIG_IsOK(res1)) {
55803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55804 }
55805 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55806 {
55807 PyThreadState* __tstate = wxPyBeginAllowThreads();
55808 result = wxGBSizerItem_GetEndPos(arg1);
55809 wxPyEndAllowThreads(__tstate);
55810 if (PyErr_Occurred()) SWIG_fail;
55811 }
55812 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55813 return resultobj;
55814 fail:
55815 return NULL;
55816 }
55817
55818
55819 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55820 PyObject *resultobj = 0;
55821 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55822 wxGridBagSizer *result = 0 ;
55823 void *argp1 = 0 ;
55824 int res1 = 0 ;
55825 PyObject *swig_obj[1] ;
55826
55827 if (!args) SWIG_fail;
55828 swig_obj[0] = args;
55829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55830 if (!SWIG_IsOK(res1)) {
55831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55832 }
55833 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55834 {
55835 PyThreadState* __tstate = wxPyBeginAllowThreads();
55836 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55837 wxPyEndAllowThreads(__tstate);
55838 if (PyErr_Occurred()) SWIG_fail;
55839 }
55840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55841 return resultobj;
55842 fail:
55843 return NULL;
55844 }
55845
55846
55847 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55848 PyObject *resultobj = 0;
55849 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55850 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55851 void *argp1 = 0 ;
55852 int res1 = 0 ;
55853 void *argp2 = 0 ;
55854 int res2 = 0 ;
55855 PyObject * obj0 = 0 ;
55856 PyObject * obj1 = 0 ;
55857 char * kwnames[] = {
55858 (char *) "self",(char *) "sizer", NULL
55859 };
55860
55861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55863 if (!SWIG_IsOK(res1)) {
55864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55865 }
55866 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55867 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55868 if (!SWIG_IsOK(res2)) {
55869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55870 }
55871 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55872 {
55873 PyThreadState* __tstate = wxPyBeginAllowThreads();
55874 (arg1)->SetGBSizer(arg2);
55875 wxPyEndAllowThreads(__tstate);
55876 if (PyErr_Occurred()) SWIG_fail;
55877 }
55878 resultobj = SWIG_Py_Void();
55879 return resultobj;
55880 fail:
55881 return NULL;
55882 }
55883
55884
55885 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55886 PyObject *obj;
55887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55888 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55889 return SWIG_Py_Void();
55890 }
55891
55892 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55893 return SWIG_Python_InitShadowInstance(args);
55894 }
55895
55896 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55897 PyObject *resultobj = 0;
55898 int arg1 = (int) 0 ;
55899 int arg2 = (int) 0 ;
55900 wxGridBagSizer *result = 0 ;
55901 int val1 ;
55902 int ecode1 = 0 ;
55903 int val2 ;
55904 int ecode2 = 0 ;
55905 PyObject * obj0 = 0 ;
55906 PyObject * obj1 = 0 ;
55907 char * kwnames[] = {
55908 (char *) "vgap",(char *) "hgap", NULL
55909 };
55910
55911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55912 if (obj0) {
55913 ecode1 = SWIG_AsVal_int(obj0, &val1);
55914 if (!SWIG_IsOK(ecode1)) {
55915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55916 }
55917 arg1 = static_cast< int >(val1);
55918 }
55919 if (obj1) {
55920 ecode2 = SWIG_AsVal_int(obj1, &val2);
55921 if (!SWIG_IsOK(ecode2)) {
55922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55923 }
55924 arg2 = static_cast< int >(val2);
55925 }
55926 {
55927 PyThreadState* __tstate = wxPyBeginAllowThreads();
55928 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55929 wxPyEndAllowThreads(__tstate);
55930 if (PyErr_Occurred()) SWIG_fail;
55931 }
55932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55933 return resultobj;
55934 fail:
55935 return NULL;
55936 }
55937
55938
55939 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55940 PyObject *resultobj = 0;
55941 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55942 PyObject *arg2 = (PyObject *) 0 ;
55943 wxGBPosition *arg3 = 0 ;
55944 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55945 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55946 int arg5 = (int) 0 ;
55947 int arg6 = (int) 0 ;
55948 PyObject *arg7 = (PyObject *) NULL ;
55949 wxGBSizerItem *result = 0 ;
55950 void *argp1 = 0 ;
55951 int res1 = 0 ;
55952 wxGBPosition temp3 ;
55953 wxGBSpan temp4 ;
55954 int val5 ;
55955 int ecode5 = 0 ;
55956 int val6 ;
55957 int ecode6 = 0 ;
55958 PyObject * obj0 = 0 ;
55959 PyObject * obj1 = 0 ;
55960 PyObject * obj2 = 0 ;
55961 PyObject * obj3 = 0 ;
55962 PyObject * obj4 = 0 ;
55963 PyObject * obj5 = 0 ;
55964 PyObject * obj6 = 0 ;
55965 char * kwnames[] = {
55966 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55967 };
55968
55969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55971 if (!SWIG_IsOK(res1)) {
55972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55973 }
55974 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55975 arg2 = obj1;
55976 {
55977 arg3 = &temp3;
55978 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55979 }
55980 if (obj3) {
55981 {
55982 arg4 = &temp4;
55983 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55984 }
55985 }
55986 if (obj4) {
55987 ecode5 = SWIG_AsVal_int(obj4, &val5);
55988 if (!SWIG_IsOK(ecode5)) {
55989 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55990 }
55991 arg5 = static_cast< int >(val5);
55992 }
55993 if (obj5) {
55994 ecode6 = SWIG_AsVal_int(obj5, &val6);
55995 if (!SWIG_IsOK(ecode6)) {
55996 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55997 }
55998 arg6 = static_cast< int >(val6);
55999 }
56000 if (obj6) {
56001 arg7 = obj6;
56002 }
56003 {
56004 PyThreadState* __tstate = wxPyBeginAllowThreads();
56005 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
56006 wxPyEndAllowThreads(__tstate);
56007 if (PyErr_Occurred()) SWIG_fail;
56008 }
56009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56010 return resultobj;
56011 fail:
56012 return NULL;
56013 }
56014
56015
56016 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56017 PyObject *resultobj = 0;
56018 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56019 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56020 wxGBSizerItem *result = 0 ;
56021 void *argp1 = 0 ;
56022 int res1 = 0 ;
56023 int res2 = 0 ;
56024 PyObject * obj0 = 0 ;
56025 PyObject * obj1 = 0 ;
56026 char * kwnames[] = {
56027 (char *) "self",(char *) "item", NULL
56028 };
56029
56030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
56031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56032 if (!SWIG_IsOK(res1)) {
56033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56034 }
56035 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56036 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
56037 if (!SWIG_IsOK(res2)) {
56038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56039 }
56040 {
56041 PyThreadState* __tstate = wxPyBeginAllowThreads();
56042 result = (wxGBSizerItem *)(arg1)->Add(arg2);
56043 wxPyEndAllowThreads(__tstate);
56044 if (PyErr_Occurred()) SWIG_fail;
56045 }
56046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56047 return resultobj;
56048 fail:
56049 return NULL;
56050 }
56051
56052
56053 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56054 PyObject *resultobj = 0;
56055 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56056 int arg2 ;
56057 int arg3 ;
56058 wxSize result;
56059 void *argp1 = 0 ;
56060 int res1 = 0 ;
56061 int val2 ;
56062 int ecode2 = 0 ;
56063 int val3 ;
56064 int ecode3 = 0 ;
56065 PyObject * obj0 = 0 ;
56066 PyObject * obj1 = 0 ;
56067 PyObject * obj2 = 0 ;
56068 char * kwnames[] = {
56069 (char *) "self",(char *) "row",(char *) "col", NULL
56070 };
56071
56072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56074 if (!SWIG_IsOK(res1)) {
56075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56076 }
56077 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56078 ecode2 = SWIG_AsVal_int(obj1, &val2);
56079 if (!SWIG_IsOK(ecode2)) {
56080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
56081 }
56082 arg2 = static_cast< int >(val2);
56083 ecode3 = SWIG_AsVal_int(obj2, &val3);
56084 if (!SWIG_IsOK(ecode3)) {
56085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
56086 }
56087 arg3 = static_cast< int >(val3);
56088 {
56089 PyThreadState* __tstate = wxPyBeginAllowThreads();
56090 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
56091 wxPyEndAllowThreads(__tstate);
56092 if (PyErr_Occurred()) SWIG_fail;
56093 }
56094 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56095 return resultobj;
56096 fail:
56097 return NULL;
56098 }
56099
56100
56101 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56102 PyObject *resultobj = 0;
56103 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56104 wxSize result;
56105 void *argp1 = 0 ;
56106 int res1 = 0 ;
56107 PyObject *swig_obj[1] ;
56108
56109 if (!args) SWIG_fail;
56110 swig_obj[0] = args;
56111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56112 if (!SWIG_IsOK(res1)) {
56113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56114 }
56115 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56116 {
56117 PyThreadState* __tstate = wxPyBeginAllowThreads();
56118 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
56119 wxPyEndAllowThreads(__tstate);
56120 if (PyErr_Occurred()) SWIG_fail;
56121 }
56122 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56123 return resultobj;
56124 fail:
56125 return NULL;
56126 }
56127
56128
56129 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56130 PyObject *resultobj = 0;
56131 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56132 wxSize *arg2 = 0 ;
56133 void *argp1 = 0 ;
56134 int res1 = 0 ;
56135 wxSize temp2 ;
56136 PyObject * obj0 = 0 ;
56137 PyObject * obj1 = 0 ;
56138 char * kwnames[] = {
56139 (char *) "self",(char *) "sz", NULL
56140 };
56141
56142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
56143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56144 if (!SWIG_IsOK(res1)) {
56145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56146 }
56147 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56148 {
56149 arg2 = &temp2;
56150 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
56151 }
56152 {
56153 PyThreadState* __tstate = wxPyBeginAllowThreads();
56154 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
56155 wxPyEndAllowThreads(__tstate);
56156 if (PyErr_Occurred()) SWIG_fail;
56157 }
56158 resultobj = SWIG_Py_Void();
56159 return resultobj;
56160 fail:
56161 return NULL;
56162 }
56163
56164
56165 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56166 PyObject *resultobj = 0;
56167 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56168 wxWindow *arg2 = (wxWindow *) 0 ;
56169 wxGBPosition result;
56170 void *argp1 = 0 ;
56171 int res1 = 0 ;
56172 void *argp2 = 0 ;
56173 int res2 = 0 ;
56174
56175 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56177 if (!SWIG_IsOK(res1)) {
56178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56179 }
56180 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56181 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56182 if (!SWIG_IsOK(res2)) {
56183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56184 }
56185 arg2 = reinterpret_cast< wxWindow * >(argp2);
56186 {
56187 PyThreadState* __tstate = wxPyBeginAllowThreads();
56188 result = (arg1)->GetItemPosition(arg2);
56189 wxPyEndAllowThreads(__tstate);
56190 if (PyErr_Occurred()) SWIG_fail;
56191 }
56192 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56193 return resultobj;
56194 fail:
56195 return NULL;
56196 }
56197
56198
56199 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56200 PyObject *resultobj = 0;
56201 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56202 wxSizer *arg2 = (wxSizer *) 0 ;
56203 wxGBPosition result;
56204 void *argp1 = 0 ;
56205 int res1 = 0 ;
56206 void *argp2 = 0 ;
56207 int res2 = 0 ;
56208
56209 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56211 if (!SWIG_IsOK(res1)) {
56212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56213 }
56214 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56215 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56216 if (!SWIG_IsOK(res2)) {
56217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56218 }
56219 arg2 = reinterpret_cast< wxSizer * >(argp2);
56220 {
56221 PyThreadState* __tstate = wxPyBeginAllowThreads();
56222 result = (arg1)->GetItemPosition(arg2);
56223 wxPyEndAllowThreads(__tstate);
56224 if (PyErr_Occurred()) SWIG_fail;
56225 }
56226 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56227 return resultobj;
56228 fail:
56229 return NULL;
56230 }
56231
56232
56233 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56234 PyObject *resultobj = 0;
56235 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56236 size_t arg2 ;
56237 wxGBPosition result;
56238 void *argp1 = 0 ;
56239 int res1 = 0 ;
56240 size_t val2 ;
56241 int ecode2 = 0 ;
56242
56243 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56245 if (!SWIG_IsOK(res1)) {
56246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56247 }
56248 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56249 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56250 if (!SWIG_IsOK(ecode2)) {
56251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56252 }
56253 arg2 = static_cast< size_t >(val2);
56254 {
56255 PyThreadState* __tstate = wxPyBeginAllowThreads();
56256 result = (arg1)->GetItemPosition(arg2);
56257 wxPyEndAllowThreads(__tstate);
56258 if (PyErr_Occurred()) SWIG_fail;
56259 }
56260 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56261 return resultobj;
56262 fail:
56263 return NULL;
56264 }
56265
56266
56267 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
56268 int argc;
56269 PyObject *argv[3];
56270
56271 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
56272 --argc;
56273 if (argc == 2) {
56274 int _v = 0;
56275 {
56276 void *vptr = 0;
56277 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56278 _v = SWIG_CheckState(res);
56279 }
56280 if (!_v) goto check_1;
56281 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
56282 }
56283 check_1:
56284
56285 if (argc == 2) {
56286 int _v = 0;
56287 {
56288 void *vptr = 0;
56289 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56290 _v = SWIG_CheckState(res);
56291 }
56292 if (!_v) goto check_2;
56293 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
56294 }
56295 check_2:
56296
56297 if (argc == 2) {
56298 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
56299 }
56300
56301 fail:
56302 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
56303 return NULL;
56304 }
56305
56306
56307 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56308 PyObject *resultobj = 0;
56309 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56310 wxWindow *arg2 = (wxWindow *) 0 ;
56311 wxGBPosition *arg3 = 0 ;
56312 bool result;
56313 void *argp1 = 0 ;
56314 int res1 = 0 ;
56315 void *argp2 = 0 ;
56316 int res2 = 0 ;
56317 wxGBPosition temp3 ;
56318
56319 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56321 if (!SWIG_IsOK(res1)) {
56322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56323 }
56324 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56325 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56326 if (!SWIG_IsOK(res2)) {
56327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56328 }
56329 arg2 = reinterpret_cast< wxWindow * >(argp2);
56330 {
56331 arg3 = &temp3;
56332 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56333 }
56334 {
56335 PyThreadState* __tstate = wxPyBeginAllowThreads();
56336 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56337 wxPyEndAllowThreads(__tstate);
56338 if (PyErr_Occurred()) SWIG_fail;
56339 }
56340 {
56341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56342 }
56343 return resultobj;
56344 fail:
56345 return NULL;
56346 }
56347
56348
56349 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56350 PyObject *resultobj = 0;
56351 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56352 wxSizer *arg2 = (wxSizer *) 0 ;
56353 wxGBPosition *arg3 = 0 ;
56354 bool result;
56355 void *argp1 = 0 ;
56356 int res1 = 0 ;
56357 void *argp2 = 0 ;
56358 int res2 = 0 ;
56359 wxGBPosition temp3 ;
56360
56361 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56363 if (!SWIG_IsOK(res1)) {
56364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56365 }
56366 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56367 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56368 if (!SWIG_IsOK(res2)) {
56369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56370 }
56371 arg2 = reinterpret_cast< wxSizer * >(argp2);
56372 {
56373 arg3 = &temp3;
56374 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56375 }
56376 {
56377 PyThreadState* __tstate = wxPyBeginAllowThreads();
56378 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56379 wxPyEndAllowThreads(__tstate);
56380 if (PyErr_Occurred()) SWIG_fail;
56381 }
56382 {
56383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56384 }
56385 return resultobj;
56386 fail:
56387 return NULL;
56388 }
56389
56390
56391 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56392 PyObject *resultobj = 0;
56393 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56394 size_t arg2 ;
56395 wxGBPosition *arg3 = 0 ;
56396 bool result;
56397 void *argp1 = 0 ;
56398 int res1 = 0 ;
56399 size_t val2 ;
56400 int ecode2 = 0 ;
56401 wxGBPosition temp3 ;
56402
56403 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56405 if (!SWIG_IsOK(res1)) {
56406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56407 }
56408 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56409 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56410 if (!SWIG_IsOK(ecode2)) {
56411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56412 }
56413 arg2 = static_cast< size_t >(val2);
56414 {
56415 arg3 = &temp3;
56416 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56417 }
56418 {
56419 PyThreadState* __tstate = wxPyBeginAllowThreads();
56420 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56421 wxPyEndAllowThreads(__tstate);
56422 if (PyErr_Occurred()) SWIG_fail;
56423 }
56424 {
56425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56426 }
56427 return resultobj;
56428 fail:
56429 return NULL;
56430 }
56431
56432
56433 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
56434 int argc;
56435 PyObject *argv[4];
56436
56437 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
56438 --argc;
56439 if (argc == 3) {
56440 int _v = 0;
56441 {
56442 void *vptr = 0;
56443 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56444 _v = SWIG_CheckState(res);
56445 }
56446 if (!_v) goto check_1;
56447 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
56448 }
56449 check_1:
56450
56451 if (argc == 3) {
56452 int _v = 0;
56453 {
56454 void *vptr = 0;
56455 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56456 _v = SWIG_CheckState(res);
56457 }
56458 if (!_v) goto check_2;
56459 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
56460 }
56461 check_2:
56462
56463 if (argc == 3) {
56464 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
56465 }
56466
56467 fail:
56468 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
56469 return NULL;
56470 }
56471
56472
56473 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56474 PyObject *resultobj = 0;
56475 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56476 wxWindow *arg2 = (wxWindow *) 0 ;
56477 wxGBSpan result;
56478 void *argp1 = 0 ;
56479 int res1 = 0 ;
56480 void *argp2 = 0 ;
56481 int res2 = 0 ;
56482
56483 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56485 if (!SWIG_IsOK(res1)) {
56486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56487 }
56488 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56489 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56490 if (!SWIG_IsOK(res2)) {
56491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56492 }
56493 arg2 = reinterpret_cast< wxWindow * >(argp2);
56494 {
56495 PyThreadState* __tstate = wxPyBeginAllowThreads();
56496 result = (arg1)->GetItemSpan(arg2);
56497 wxPyEndAllowThreads(__tstate);
56498 if (PyErr_Occurred()) SWIG_fail;
56499 }
56500 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56501 return resultobj;
56502 fail:
56503 return NULL;
56504 }
56505
56506
56507 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56508 PyObject *resultobj = 0;
56509 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56510 wxSizer *arg2 = (wxSizer *) 0 ;
56511 wxGBSpan result;
56512 void *argp1 = 0 ;
56513 int res1 = 0 ;
56514 void *argp2 = 0 ;
56515 int res2 = 0 ;
56516
56517 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56519 if (!SWIG_IsOK(res1)) {
56520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56521 }
56522 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56523 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56524 if (!SWIG_IsOK(res2)) {
56525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56526 }
56527 arg2 = reinterpret_cast< wxSizer * >(argp2);
56528 {
56529 PyThreadState* __tstate = wxPyBeginAllowThreads();
56530 result = (arg1)->GetItemSpan(arg2);
56531 wxPyEndAllowThreads(__tstate);
56532 if (PyErr_Occurred()) SWIG_fail;
56533 }
56534 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56535 return resultobj;
56536 fail:
56537 return NULL;
56538 }
56539
56540
56541 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56542 PyObject *resultobj = 0;
56543 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56544 size_t arg2 ;
56545 wxGBSpan result;
56546 void *argp1 = 0 ;
56547 int res1 = 0 ;
56548 size_t val2 ;
56549 int ecode2 = 0 ;
56550
56551 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56553 if (!SWIG_IsOK(res1)) {
56554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56555 }
56556 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56557 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56558 if (!SWIG_IsOK(ecode2)) {
56559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56560 }
56561 arg2 = static_cast< size_t >(val2);
56562 {
56563 PyThreadState* __tstate = wxPyBeginAllowThreads();
56564 result = (arg1)->GetItemSpan(arg2);
56565 wxPyEndAllowThreads(__tstate);
56566 if (PyErr_Occurred()) SWIG_fail;
56567 }
56568 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56569 return resultobj;
56570 fail:
56571 return NULL;
56572 }
56573
56574
56575 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
56576 int argc;
56577 PyObject *argv[3];
56578
56579 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
56580 --argc;
56581 if (argc == 2) {
56582 int _v = 0;
56583 {
56584 void *vptr = 0;
56585 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56586 _v = SWIG_CheckState(res);
56587 }
56588 if (!_v) goto check_1;
56589 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
56590 }
56591 check_1:
56592
56593 if (argc == 2) {
56594 int _v = 0;
56595 {
56596 void *vptr = 0;
56597 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56598 _v = SWIG_CheckState(res);
56599 }
56600 if (!_v) goto check_2;
56601 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
56602 }
56603 check_2:
56604
56605 if (argc == 2) {
56606 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
56607 }
56608
56609 fail:
56610 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
56611 return NULL;
56612 }
56613
56614
56615 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56616 PyObject *resultobj = 0;
56617 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56618 wxWindow *arg2 = (wxWindow *) 0 ;
56619 wxGBSpan *arg3 = 0 ;
56620 bool result;
56621 void *argp1 = 0 ;
56622 int res1 = 0 ;
56623 void *argp2 = 0 ;
56624 int res2 = 0 ;
56625 wxGBSpan temp3 ;
56626
56627 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56629 if (!SWIG_IsOK(res1)) {
56630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56631 }
56632 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56633 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56634 if (!SWIG_IsOK(res2)) {
56635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56636 }
56637 arg2 = reinterpret_cast< wxWindow * >(argp2);
56638 {
56639 arg3 = &temp3;
56640 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56641 }
56642 {
56643 PyThreadState* __tstate = wxPyBeginAllowThreads();
56644 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56645 wxPyEndAllowThreads(__tstate);
56646 if (PyErr_Occurred()) SWIG_fail;
56647 }
56648 {
56649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56650 }
56651 return resultobj;
56652 fail:
56653 return NULL;
56654 }
56655
56656
56657 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56658 PyObject *resultobj = 0;
56659 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56660 wxSizer *arg2 = (wxSizer *) 0 ;
56661 wxGBSpan *arg3 = 0 ;
56662 bool result;
56663 void *argp1 = 0 ;
56664 int res1 = 0 ;
56665 void *argp2 = 0 ;
56666 int res2 = 0 ;
56667 wxGBSpan temp3 ;
56668
56669 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56671 if (!SWIG_IsOK(res1)) {
56672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56673 }
56674 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56675 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56676 if (!SWIG_IsOK(res2)) {
56677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56678 }
56679 arg2 = reinterpret_cast< wxSizer * >(argp2);
56680 {
56681 arg3 = &temp3;
56682 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56683 }
56684 {
56685 PyThreadState* __tstate = wxPyBeginAllowThreads();
56686 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56687 wxPyEndAllowThreads(__tstate);
56688 if (PyErr_Occurred()) SWIG_fail;
56689 }
56690 {
56691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56692 }
56693 return resultobj;
56694 fail:
56695 return NULL;
56696 }
56697
56698
56699 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56700 PyObject *resultobj = 0;
56701 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56702 size_t arg2 ;
56703 wxGBSpan *arg3 = 0 ;
56704 bool result;
56705 void *argp1 = 0 ;
56706 int res1 = 0 ;
56707 size_t val2 ;
56708 int ecode2 = 0 ;
56709 wxGBSpan temp3 ;
56710
56711 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56713 if (!SWIG_IsOK(res1)) {
56714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56715 }
56716 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56717 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56718 if (!SWIG_IsOK(ecode2)) {
56719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56720 }
56721 arg2 = static_cast< size_t >(val2);
56722 {
56723 arg3 = &temp3;
56724 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56725 }
56726 {
56727 PyThreadState* __tstate = wxPyBeginAllowThreads();
56728 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56729 wxPyEndAllowThreads(__tstate);
56730 if (PyErr_Occurred()) SWIG_fail;
56731 }
56732 {
56733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56734 }
56735 return resultobj;
56736 fail:
56737 return NULL;
56738 }
56739
56740
56741 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56742 int argc;
56743 PyObject *argv[4];
56744
56745 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56746 --argc;
56747 if (argc == 3) {
56748 int _v = 0;
56749 {
56750 void *vptr = 0;
56751 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56752 _v = SWIG_CheckState(res);
56753 }
56754 if (!_v) goto check_1;
56755 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56756 }
56757 check_1:
56758
56759 if (argc == 3) {
56760 int _v = 0;
56761 {
56762 void *vptr = 0;
56763 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56764 _v = SWIG_CheckState(res);
56765 }
56766 if (!_v) goto check_2;
56767 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56768 }
56769 check_2:
56770
56771 if (argc == 3) {
56772 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56773 }
56774
56775 fail:
56776 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56777 return NULL;
56778 }
56779
56780
56781 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56782 PyObject *resultobj = 0;
56783 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56784 wxWindow *arg2 = (wxWindow *) 0 ;
56785 wxGBSizerItem *result = 0 ;
56786 void *argp1 = 0 ;
56787 int res1 = 0 ;
56788 void *argp2 = 0 ;
56789 int res2 = 0 ;
56790
56791 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56793 if (!SWIG_IsOK(res1)) {
56794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56795 }
56796 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56797 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56798 if (!SWIG_IsOK(res2)) {
56799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56800 }
56801 arg2 = reinterpret_cast< wxWindow * >(argp2);
56802 {
56803 PyThreadState* __tstate = wxPyBeginAllowThreads();
56804 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56805 wxPyEndAllowThreads(__tstate);
56806 if (PyErr_Occurred()) SWIG_fail;
56807 }
56808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56809 return resultobj;
56810 fail:
56811 return NULL;
56812 }
56813
56814
56815 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56816 PyObject *resultobj = 0;
56817 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56818 wxSizer *arg2 = (wxSizer *) 0 ;
56819 wxGBSizerItem *result = 0 ;
56820 void *argp1 = 0 ;
56821 int res1 = 0 ;
56822 void *argp2 = 0 ;
56823 int res2 = 0 ;
56824
56825 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56827 if (!SWIG_IsOK(res1)) {
56828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56829 }
56830 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56831 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56832 if (!SWIG_IsOK(res2)) {
56833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56834 }
56835 arg2 = reinterpret_cast< wxSizer * >(argp2);
56836 {
56837 PyThreadState* __tstate = wxPyBeginAllowThreads();
56838 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56839 wxPyEndAllowThreads(__tstate);
56840 if (PyErr_Occurred()) SWIG_fail;
56841 }
56842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56843 return resultobj;
56844 fail:
56845 return NULL;
56846 }
56847
56848
56849 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56850 int argc;
56851 PyObject *argv[3];
56852
56853 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56854 --argc;
56855 if (argc == 2) {
56856 int _v = 0;
56857 {
56858 void *vptr = 0;
56859 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56860 _v = SWIG_CheckState(res);
56861 }
56862 if (!_v) goto check_1;
56863 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56864 }
56865 check_1:
56866
56867 if (argc == 2) {
56868 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56869 }
56870
56871 fail:
56872 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56873 return NULL;
56874 }
56875
56876
56877 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56878 PyObject *resultobj = 0;
56879 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56880 wxGBPosition *arg2 = 0 ;
56881 wxGBSizerItem *result = 0 ;
56882 void *argp1 = 0 ;
56883 int res1 = 0 ;
56884 wxGBPosition temp2 ;
56885 PyObject * obj0 = 0 ;
56886 PyObject * obj1 = 0 ;
56887 char * kwnames[] = {
56888 (char *) "self",(char *) "pos", NULL
56889 };
56890
56891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56893 if (!SWIG_IsOK(res1)) {
56894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56895 }
56896 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56897 {
56898 arg2 = &temp2;
56899 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56900 }
56901 {
56902 PyThreadState* __tstate = wxPyBeginAllowThreads();
56903 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56904 wxPyEndAllowThreads(__tstate);
56905 if (PyErr_Occurred()) SWIG_fail;
56906 }
56907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56908 return resultobj;
56909 fail:
56910 return NULL;
56911 }
56912
56913
56914 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56915 PyObject *resultobj = 0;
56916 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56917 wxPoint *arg2 = 0 ;
56918 wxGBSizerItem *result = 0 ;
56919 void *argp1 = 0 ;
56920 int res1 = 0 ;
56921 wxPoint temp2 ;
56922 PyObject * obj0 = 0 ;
56923 PyObject * obj1 = 0 ;
56924 char * kwnames[] = {
56925 (char *) "self",(char *) "pt", NULL
56926 };
56927
56928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56930 if (!SWIG_IsOK(res1)) {
56931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56932 }
56933 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56934 {
56935 arg2 = &temp2;
56936 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56937 }
56938 {
56939 PyThreadState* __tstate = wxPyBeginAllowThreads();
56940 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56941 wxPyEndAllowThreads(__tstate);
56942 if (PyErr_Occurred()) SWIG_fail;
56943 }
56944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56945 return resultobj;
56946 fail:
56947 return NULL;
56948 }
56949
56950
56951 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56952 PyObject *resultobj = 0;
56953 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56954 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56955 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56956 bool result;
56957 void *argp1 = 0 ;
56958 int res1 = 0 ;
56959 void *argp2 = 0 ;
56960 int res2 = 0 ;
56961 void *argp3 = 0 ;
56962 int res3 = 0 ;
56963 PyObject * obj0 = 0 ;
56964 PyObject * obj1 = 0 ;
56965 PyObject * obj2 = 0 ;
56966 char * kwnames[] = {
56967 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56968 };
56969
56970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56972 if (!SWIG_IsOK(res1)) {
56973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56974 }
56975 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56976 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56977 if (!SWIG_IsOK(res2)) {
56978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56979 }
56980 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56981 if (obj2) {
56982 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56983 if (!SWIG_IsOK(res3)) {
56984 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56985 }
56986 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56987 }
56988 {
56989 PyThreadState* __tstate = wxPyBeginAllowThreads();
56990 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56991 wxPyEndAllowThreads(__tstate);
56992 if (PyErr_Occurred()) SWIG_fail;
56993 }
56994 {
56995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56996 }
56997 return resultobj;
56998 fail:
56999 return NULL;
57000 }
57001
57002
57003 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57004 PyObject *resultobj = 0;
57005 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
57006 wxGBPosition *arg2 = 0 ;
57007 wxGBSpan *arg3 = 0 ;
57008 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
57009 bool result;
57010 void *argp1 = 0 ;
57011 int res1 = 0 ;
57012 wxGBPosition temp2 ;
57013 wxGBSpan temp3 ;
57014 void *argp4 = 0 ;
57015 int res4 = 0 ;
57016 PyObject * obj0 = 0 ;
57017 PyObject * obj1 = 0 ;
57018 PyObject * obj2 = 0 ;
57019 PyObject * obj3 = 0 ;
57020 char * kwnames[] = {
57021 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
57022 };
57023
57024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
57026 if (!SWIG_IsOK(res1)) {
57027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
57028 }
57029 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
57030 {
57031 arg2 = &temp2;
57032 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
57033 }
57034 {
57035 arg3 = &temp3;
57036 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
57037 }
57038 if (obj3) {
57039 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
57040 if (!SWIG_IsOK(res4)) {
57041 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
57042 }
57043 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
57044 }
57045 {
57046 PyThreadState* __tstate = wxPyBeginAllowThreads();
57047 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
57048 wxPyEndAllowThreads(__tstate);
57049 if (PyErr_Occurred()) SWIG_fail;
57050 }
57051 {
57052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57053 }
57054 return resultobj;
57055 fail:
57056 return NULL;
57057 }
57058
57059
57060 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57061 PyObject *obj;
57062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57063 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
57064 return SWIG_Py_Void();
57065 }
57066
57067 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57068 return SWIG_Python_InitShadowInstance(args);
57069 }
57070
57071 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57072 PyObject *resultobj = 0;
57073 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57074 wxRelationship arg2 ;
57075 wxWindow *arg3 = (wxWindow *) 0 ;
57076 wxEdge arg4 ;
57077 int arg5 = (int) 0 ;
57078 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
57079 void *argp1 = 0 ;
57080 int res1 = 0 ;
57081 int val2 ;
57082 int ecode2 = 0 ;
57083 void *argp3 = 0 ;
57084 int res3 = 0 ;
57085 int val4 ;
57086 int ecode4 = 0 ;
57087 int val5 ;
57088 int ecode5 = 0 ;
57089 int val6 ;
57090 int ecode6 = 0 ;
57091 PyObject * obj0 = 0 ;
57092 PyObject * obj1 = 0 ;
57093 PyObject * obj2 = 0 ;
57094 PyObject * obj3 = 0 ;
57095 PyObject * obj4 = 0 ;
57096 PyObject * obj5 = 0 ;
57097 char * kwnames[] = {
57098 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
57099 };
57100
57101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
57102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57103 if (!SWIG_IsOK(res1)) {
57104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57105 }
57106 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57107 ecode2 = SWIG_AsVal_int(obj1, &val2);
57108 if (!SWIG_IsOK(ecode2)) {
57109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
57110 }
57111 arg2 = static_cast< wxRelationship >(val2);
57112 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57113 if (!SWIG_IsOK(res3)) {
57114 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
57115 }
57116 arg3 = reinterpret_cast< wxWindow * >(argp3);
57117 ecode4 = SWIG_AsVal_int(obj3, &val4);
57118 if (!SWIG_IsOK(ecode4)) {
57119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
57120 }
57121 arg4 = static_cast< wxEdge >(val4);
57122 if (obj4) {
57123 ecode5 = SWIG_AsVal_int(obj4, &val5);
57124 if (!SWIG_IsOK(ecode5)) {
57125 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
57126 }
57127 arg5 = static_cast< int >(val5);
57128 }
57129 if (obj5) {
57130 ecode6 = SWIG_AsVal_int(obj5, &val6);
57131 if (!SWIG_IsOK(ecode6)) {
57132 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
57133 }
57134 arg6 = static_cast< int >(val6);
57135 }
57136 {
57137 PyThreadState* __tstate = wxPyBeginAllowThreads();
57138 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
57139 wxPyEndAllowThreads(__tstate);
57140 if (PyErr_Occurred()) SWIG_fail;
57141 }
57142 resultobj = SWIG_Py_Void();
57143 return resultobj;
57144 fail:
57145 return NULL;
57146 }
57147
57148
57149 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57150 PyObject *resultobj = 0;
57151 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57152 wxWindow *arg2 = (wxWindow *) 0 ;
57153 int arg3 = (int) 0 ;
57154 void *argp1 = 0 ;
57155 int res1 = 0 ;
57156 void *argp2 = 0 ;
57157 int res2 = 0 ;
57158 int val3 ;
57159 int ecode3 = 0 ;
57160 PyObject * obj0 = 0 ;
57161 PyObject * obj1 = 0 ;
57162 PyObject * obj2 = 0 ;
57163 char * kwnames[] = {
57164 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57165 };
57166
57167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57169 if (!SWIG_IsOK(res1)) {
57170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57171 }
57172 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57174 if (!SWIG_IsOK(res2)) {
57175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57176 }
57177 arg2 = reinterpret_cast< wxWindow * >(argp2);
57178 if (obj2) {
57179 ecode3 = SWIG_AsVal_int(obj2, &val3);
57180 if (!SWIG_IsOK(ecode3)) {
57181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
57182 }
57183 arg3 = static_cast< int >(val3);
57184 }
57185 {
57186 PyThreadState* __tstate = wxPyBeginAllowThreads();
57187 (arg1)->LeftOf(arg2,arg3);
57188 wxPyEndAllowThreads(__tstate);
57189 if (PyErr_Occurred()) SWIG_fail;
57190 }
57191 resultobj = SWIG_Py_Void();
57192 return resultobj;
57193 fail:
57194 return NULL;
57195 }
57196
57197
57198 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57199 PyObject *resultobj = 0;
57200 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57201 wxWindow *arg2 = (wxWindow *) 0 ;
57202 int arg3 = (int) 0 ;
57203 void *argp1 = 0 ;
57204 int res1 = 0 ;
57205 void *argp2 = 0 ;
57206 int res2 = 0 ;
57207 int val3 ;
57208 int ecode3 = 0 ;
57209 PyObject * obj0 = 0 ;
57210 PyObject * obj1 = 0 ;
57211 PyObject * obj2 = 0 ;
57212 char * kwnames[] = {
57213 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57214 };
57215
57216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57218 if (!SWIG_IsOK(res1)) {
57219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57220 }
57221 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57223 if (!SWIG_IsOK(res2)) {
57224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57225 }
57226 arg2 = reinterpret_cast< wxWindow * >(argp2);
57227 if (obj2) {
57228 ecode3 = SWIG_AsVal_int(obj2, &val3);
57229 if (!SWIG_IsOK(ecode3)) {
57230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
57231 }
57232 arg3 = static_cast< int >(val3);
57233 }
57234 {
57235 PyThreadState* __tstate = wxPyBeginAllowThreads();
57236 (arg1)->RightOf(arg2,arg3);
57237 wxPyEndAllowThreads(__tstate);
57238 if (PyErr_Occurred()) SWIG_fail;
57239 }
57240 resultobj = SWIG_Py_Void();
57241 return resultobj;
57242 fail:
57243 return NULL;
57244 }
57245
57246
57247 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57248 PyObject *resultobj = 0;
57249 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57250 wxWindow *arg2 = (wxWindow *) 0 ;
57251 int arg3 = (int) 0 ;
57252 void *argp1 = 0 ;
57253 int res1 = 0 ;
57254 void *argp2 = 0 ;
57255 int res2 = 0 ;
57256 int val3 ;
57257 int ecode3 = 0 ;
57258 PyObject * obj0 = 0 ;
57259 PyObject * obj1 = 0 ;
57260 PyObject * obj2 = 0 ;
57261 char * kwnames[] = {
57262 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57263 };
57264
57265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57267 if (!SWIG_IsOK(res1)) {
57268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57269 }
57270 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57272 if (!SWIG_IsOK(res2)) {
57273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
57274 }
57275 arg2 = reinterpret_cast< wxWindow * >(argp2);
57276 if (obj2) {
57277 ecode3 = SWIG_AsVal_int(obj2, &val3);
57278 if (!SWIG_IsOK(ecode3)) {
57279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
57280 }
57281 arg3 = static_cast< int >(val3);
57282 }
57283 {
57284 PyThreadState* __tstate = wxPyBeginAllowThreads();
57285 (arg1)->Above(arg2,arg3);
57286 wxPyEndAllowThreads(__tstate);
57287 if (PyErr_Occurred()) SWIG_fail;
57288 }
57289 resultobj = SWIG_Py_Void();
57290 return resultobj;
57291 fail:
57292 return NULL;
57293 }
57294
57295
57296 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57297 PyObject *resultobj = 0;
57298 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57299 wxWindow *arg2 = (wxWindow *) 0 ;
57300 int arg3 = (int) 0 ;
57301 void *argp1 = 0 ;
57302 int res1 = 0 ;
57303 void *argp2 = 0 ;
57304 int res2 = 0 ;
57305 int val3 ;
57306 int ecode3 = 0 ;
57307 PyObject * obj0 = 0 ;
57308 PyObject * obj1 = 0 ;
57309 PyObject * obj2 = 0 ;
57310 char * kwnames[] = {
57311 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57312 };
57313
57314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57316 if (!SWIG_IsOK(res1)) {
57317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57318 }
57319 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57321 if (!SWIG_IsOK(res2)) {
57322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
57323 }
57324 arg2 = reinterpret_cast< wxWindow * >(argp2);
57325 if (obj2) {
57326 ecode3 = SWIG_AsVal_int(obj2, &val3);
57327 if (!SWIG_IsOK(ecode3)) {
57328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
57329 }
57330 arg3 = static_cast< int >(val3);
57331 }
57332 {
57333 PyThreadState* __tstate = wxPyBeginAllowThreads();
57334 (arg1)->Below(arg2,arg3);
57335 wxPyEndAllowThreads(__tstate);
57336 if (PyErr_Occurred()) SWIG_fail;
57337 }
57338 resultobj = SWIG_Py_Void();
57339 return resultobj;
57340 fail:
57341 return NULL;
57342 }
57343
57344
57345 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57346 PyObject *resultobj = 0;
57347 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57348 wxWindow *arg2 = (wxWindow *) 0 ;
57349 wxEdge arg3 ;
57350 int arg4 = (int) 0 ;
57351 void *argp1 = 0 ;
57352 int res1 = 0 ;
57353 void *argp2 = 0 ;
57354 int res2 = 0 ;
57355 int val3 ;
57356 int ecode3 = 0 ;
57357 int val4 ;
57358 int ecode4 = 0 ;
57359 PyObject * obj0 = 0 ;
57360 PyObject * obj1 = 0 ;
57361 PyObject * obj2 = 0 ;
57362 PyObject * obj3 = 0 ;
57363 char * kwnames[] = {
57364 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
57365 };
57366
57367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57369 if (!SWIG_IsOK(res1)) {
57370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57371 }
57372 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57374 if (!SWIG_IsOK(res2)) {
57375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
57376 }
57377 arg2 = reinterpret_cast< wxWindow * >(argp2);
57378 ecode3 = SWIG_AsVal_int(obj2, &val3);
57379 if (!SWIG_IsOK(ecode3)) {
57380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
57381 }
57382 arg3 = static_cast< wxEdge >(val3);
57383 if (obj3) {
57384 ecode4 = SWIG_AsVal_int(obj3, &val4);
57385 if (!SWIG_IsOK(ecode4)) {
57386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
57387 }
57388 arg4 = static_cast< int >(val4);
57389 }
57390 {
57391 PyThreadState* __tstate = wxPyBeginAllowThreads();
57392 (arg1)->SameAs(arg2,arg3,arg4);
57393 wxPyEndAllowThreads(__tstate);
57394 if (PyErr_Occurred()) SWIG_fail;
57395 }
57396 resultobj = SWIG_Py_Void();
57397 return resultobj;
57398 fail:
57399 return NULL;
57400 }
57401
57402
57403 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57404 PyObject *resultobj = 0;
57405 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57406 wxWindow *arg2 = (wxWindow *) 0 ;
57407 wxEdge arg3 ;
57408 int arg4 ;
57409 void *argp1 = 0 ;
57410 int res1 = 0 ;
57411 void *argp2 = 0 ;
57412 int res2 = 0 ;
57413 int val3 ;
57414 int ecode3 = 0 ;
57415 int val4 ;
57416 int ecode4 = 0 ;
57417 PyObject * obj0 = 0 ;
57418 PyObject * obj1 = 0 ;
57419 PyObject * obj2 = 0 ;
57420 PyObject * obj3 = 0 ;
57421 char * kwnames[] = {
57422 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
57423 };
57424
57425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57427 if (!SWIG_IsOK(res1)) {
57428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57429 }
57430 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57431 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57432 if (!SWIG_IsOK(res2)) {
57433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57434 }
57435 arg2 = reinterpret_cast< wxWindow * >(argp2);
57436 ecode3 = SWIG_AsVal_int(obj2, &val3);
57437 if (!SWIG_IsOK(ecode3)) {
57438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
57439 }
57440 arg3 = static_cast< wxEdge >(val3);
57441 ecode4 = SWIG_AsVal_int(obj3, &val4);
57442 if (!SWIG_IsOK(ecode4)) {
57443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
57444 }
57445 arg4 = static_cast< int >(val4);
57446 {
57447 PyThreadState* __tstate = wxPyBeginAllowThreads();
57448 (arg1)->PercentOf(arg2,arg3,arg4);
57449 wxPyEndAllowThreads(__tstate);
57450 if (PyErr_Occurred()) SWIG_fail;
57451 }
57452 resultobj = SWIG_Py_Void();
57453 return resultobj;
57454 fail:
57455 return NULL;
57456 }
57457
57458
57459 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57460 PyObject *resultobj = 0;
57461 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57462 int arg2 ;
57463 void *argp1 = 0 ;
57464 int res1 = 0 ;
57465 int val2 ;
57466 int ecode2 = 0 ;
57467 PyObject * obj0 = 0 ;
57468 PyObject * obj1 = 0 ;
57469 char * kwnames[] = {
57470 (char *) "self",(char *) "val", NULL
57471 };
57472
57473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
57474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57475 if (!SWIG_IsOK(res1)) {
57476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57477 }
57478 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57479 ecode2 = SWIG_AsVal_int(obj1, &val2);
57480 if (!SWIG_IsOK(ecode2)) {
57481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
57482 }
57483 arg2 = static_cast< int >(val2);
57484 {
57485 PyThreadState* __tstate = wxPyBeginAllowThreads();
57486 (arg1)->Absolute(arg2);
57487 wxPyEndAllowThreads(__tstate);
57488 if (PyErr_Occurred()) SWIG_fail;
57489 }
57490 resultobj = SWIG_Py_Void();
57491 return resultobj;
57492 fail:
57493 return NULL;
57494 }
57495
57496
57497 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57498 PyObject *resultobj = 0;
57499 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57500 void *argp1 = 0 ;
57501 int res1 = 0 ;
57502 PyObject *swig_obj[1] ;
57503
57504 if (!args) SWIG_fail;
57505 swig_obj[0] = args;
57506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57507 if (!SWIG_IsOK(res1)) {
57508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57509 }
57510 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57511 {
57512 PyThreadState* __tstate = wxPyBeginAllowThreads();
57513 (arg1)->Unconstrained();
57514 wxPyEndAllowThreads(__tstate);
57515 if (PyErr_Occurred()) SWIG_fail;
57516 }
57517 resultobj = SWIG_Py_Void();
57518 return resultobj;
57519 fail:
57520 return NULL;
57521 }
57522
57523
57524 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57525 PyObject *resultobj = 0;
57526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57527 void *argp1 = 0 ;
57528 int res1 = 0 ;
57529 PyObject *swig_obj[1] ;
57530
57531 if (!args) SWIG_fail;
57532 swig_obj[0] = args;
57533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57534 if (!SWIG_IsOK(res1)) {
57535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57536 }
57537 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57538 {
57539 PyThreadState* __tstate = wxPyBeginAllowThreads();
57540 (arg1)->AsIs();
57541 wxPyEndAllowThreads(__tstate);
57542 if (PyErr_Occurred()) SWIG_fail;
57543 }
57544 resultobj = SWIG_Py_Void();
57545 return resultobj;
57546 fail:
57547 return NULL;
57548 }
57549
57550
57551 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57552 PyObject *resultobj = 0;
57553 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57554 wxWindow *result = 0 ;
57555 void *argp1 = 0 ;
57556 int res1 = 0 ;
57557 PyObject *swig_obj[1] ;
57558
57559 if (!args) SWIG_fail;
57560 swig_obj[0] = args;
57561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57562 if (!SWIG_IsOK(res1)) {
57563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57564 }
57565 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57566 {
57567 PyThreadState* __tstate = wxPyBeginAllowThreads();
57568 result = (wxWindow *)(arg1)->GetOtherWindow();
57569 wxPyEndAllowThreads(__tstate);
57570 if (PyErr_Occurred()) SWIG_fail;
57571 }
57572 {
57573 resultobj = wxPyMake_wxObject(result, 0);
57574 }
57575 return resultobj;
57576 fail:
57577 return NULL;
57578 }
57579
57580
57581 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57582 PyObject *resultobj = 0;
57583 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57584 wxEdge result;
57585 void *argp1 = 0 ;
57586 int res1 = 0 ;
57587 PyObject *swig_obj[1] ;
57588
57589 if (!args) SWIG_fail;
57590 swig_obj[0] = args;
57591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57592 if (!SWIG_IsOK(res1)) {
57593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57594 }
57595 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57596 {
57597 PyThreadState* __tstate = wxPyBeginAllowThreads();
57598 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
57599 wxPyEndAllowThreads(__tstate);
57600 if (PyErr_Occurred()) SWIG_fail;
57601 }
57602 resultobj = SWIG_From_int(static_cast< int >(result));
57603 return resultobj;
57604 fail:
57605 return NULL;
57606 }
57607
57608
57609 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57610 PyObject *resultobj = 0;
57611 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57612 wxEdge arg2 ;
57613 void *argp1 = 0 ;
57614 int res1 = 0 ;
57615 int val2 ;
57616 int ecode2 = 0 ;
57617 PyObject * obj0 = 0 ;
57618 PyObject * obj1 = 0 ;
57619 char * kwnames[] = {
57620 (char *) "self",(char *) "which", NULL
57621 };
57622
57623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
57624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57625 if (!SWIG_IsOK(res1)) {
57626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57627 }
57628 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57629 ecode2 = SWIG_AsVal_int(obj1, &val2);
57630 if (!SWIG_IsOK(ecode2)) {
57631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57632 }
57633 arg2 = static_cast< wxEdge >(val2);
57634 {
57635 PyThreadState* __tstate = wxPyBeginAllowThreads();
57636 (arg1)->SetEdge(arg2);
57637 wxPyEndAllowThreads(__tstate);
57638 if (PyErr_Occurred()) SWIG_fail;
57639 }
57640 resultobj = SWIG_Py_Void();
57641 return resultobj;
57642 fail:
57643 return NULL;
57644 }
57645
57646
57647 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57648 PyObject *resultobj = 0;
57649 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57650 int arg2 ;
57651 void *argp1 = 0 ;
57652 int res1 = 0 ;
57653 int val2 ;
57654 int ecode2 = 0 ;
57655 PyObject * obj0 = 0 ;
57656 PyObject * obj1 = 0 ;
57657 char * kwnames[] = {
57658 (char *) "self",(char *) "v", NULL
57659 };
57660
57661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
57662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57663 if (!SWIG_IsOK(res1)) {
57664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57665 }
57666 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57667 ecode2 = SWIG_AsVal_int(obj1, &val2);
57668 if (!SWIG_IsOK(ecode2)) {
57669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
57670 }
57671 arg2 = static_cast< int >(val2);
57672 {
57673 PyThreadState* __tstate = wxPyBeginAllowThreads();
57674 (arg1)->SetValue(arg2);
57675 wxPyEndAllowThreads(__tstate);
57676 if (PyErr_Occurred()) SWIG_fail;
57677 }
57678 resultobj = SWIG_Py_Void();
57679 return resultobj;
57680 fail:
57681 return NULL;
57682 }
57683
57684
57685 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57686 PyObject *resultobj = 0;
57687 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57688 int result;
57689 void *argp1 = 0 ;
57690 int res1 = 0 ;
57691 PyObject *swig_obj[1] ;
57692
57693 if (!args) SWIG_fail;
57694 swig_obj[0] = args;
57695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57696 if (!SWIG_IsOK(res1)) {
57697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57698 }
57699 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57700 {
57701 PyThreadState* __tstate = wxPyBeginAllowThreads();
57702 result = (int)(arg1)->GetMargin();
57703 wxPyEndAllowThreads(__tstate);
57704 if (PyErr_Occurred()) SWIG_fail;
57705 }
57706 resultobj = SWIG_From_int(static_cast< int >(result));
57707 return resultobj;
57708 fail:
57709 return NULL;
57710 }
57711
57712
57713 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57714 PyObject *resultobj = 0;
57715 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57716 int arg2 ;
57717 void *argp1 = 0 ;
57718 int res1 = 0 ;
57719 int val2 ;
57720 int ecode2 = 0 ;
57721 PyObject * obj0 = 0 ;
57722 PyObject * obj1 = 0 ;
57723 char * kwnames[] = {
57724 (char *) "self",(char *) "m", NULL
57725 };
57726
57727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57729 if (!SWIG_IsOK(res1)) {
57730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57731 }
57732 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57733 ecode2 = SWIG_AsVal_int(obj1, &val2);
57734 if (!SWIG_IsOK(ecode2)) {
57735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57736 }
57737 arg2 = static_cast< int >(val2);
57738 {
57739 PyThreadState* __tstate = wxPyBeginAllowThreads();
57740 (arg1)->SetMargin(arg2);
57741 wxPyEndAllowThreads(__tstate);
57742 if (PyErr_Occurred()) SWIG_fail;
57743 }
57744 resultobj = SWIG_Py_Void();
57745 return resultobj;
57746 fail:
57747 return NULL;
57748 }
57749
57750
57751 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57752 PyObject *resultobj = 0;
57753 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57754 int result;
57755 void *argp1 = 0 ;
57756 int res1 = 0 ;
57757 PyObject *swig_obj[1] ;
57758
57759 if (!args) SWIG_fail;
57760 swig_obj[0] = args;
57761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57762 if (!SWIG_IsOK(res1)) {
57763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57764 }
57765 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57766 {
57767 PyThreadState* __tstate = wxPyBeginAllowThreads();
57768 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57769 wxPyEndAllowThreads(__tstate);
57770 if (PyErr_Occurred()) SWIG_fail;
57771 }
57772 resultobj = SWIG_From_int(static_cast< int >(result));
57773 return resultobj;
57774 fail:
57775 return NULL;
57776 }
57777
57778
57779 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57780 PyObject *resultobj = 0;
57781 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57782 int result;
57783 void *argp1 = 0 ;
57784 int res1 = 0 ;
57785 PyObject *swig_obj[1] ;
57786
57787 if (!args) SWIG_fail;
57788 swig_obj[0] = args;
57789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57790 if (!SWIG_IsOK(res1)) {
57791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57792 }
57793 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57794 {
57795 PyThreadState* __tstate = wxPyBeginAllowThreads();
57796 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57797 wxPyEndAllowThreads(__tstate);
57798 if (PyErr_Occurred()) SWIG_fail;
57799 }
57800 resultobj = SWIG_From_int(static_cast< int >(result));
57801 return resultobj;
57802 fail:
57803 return NULL;
57804 }
57805
57806
57807 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57808 PyObject *resultobj = 0;
57809 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57810 int result;
57811 void *argp1 = 0 ;
57812 int res1 = 0 ;
57813 PyObject *swig_obj[1] ;
57814
57815 if (!args) SWIG_fail;
57816 swig_obj[0] = args;
57817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57818 if (!SWIG_IsOK(res1)) {
57819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57820 }
57821 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57822 {
57823 PyThreadState* __tstate = wxPyBeginAllowThreads();
57824 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57825 wxPyEndAllowThreads(__tstate);
57826 if (PyErr_Occurred()) SWIG_fail;
57827 }
57828 resultobj = SWIG_From_int(static_cast< int >(result));
57829 return resultobj;
57830 fail:
57831 return NULL;
57832 }
57833
57834
57835 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57836 PyObject *resultobj = 0;
57837 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57838 bool result;
57839 void *argp1 = 0 ;
57840 int res1 = 0 ;
57841 PyObject *swig_obj[1] ;
57842
57843 if (!args) SWIG_fail;
57844 swig_obj[0] = args;
57845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57846 if (!SWIG_IsOK(res1)) {
57847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57848 }
57849 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57850 {
57851 PyThreadState* __tstate = wxPyBeginAllowThreads();
57852 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57853 wxPyEndAllowThreads(__tstate);
57854 if (PyErr_Occurred()) SWIG_fail;
57855 }
57856 {
57857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57858 }
57859 return resultobj;
57860 fail:
57861 return NULL;
57862 }
57863
57864
57865 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57866 PyObject *resultobj = 0;
57867 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57868 bool arg2 ;
57869 void *argp1 = 0 ;
57870 int res1 = 0 ;
57871 bool val2 ;
57872 int ecode2 = 0 ;
57873 PyObject * obj0 = 0 ;
57874 PyObject * obj1 = 0 ;
57875 char * kwnames[] = {
57876 (char *) "self",(char *) "d", NULL
57877 };
57878
57879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57881 if (!SWIG_IsOK(res1)) {
57882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57883 }
57884 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57885 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57886 if (!SWIG_IsOK(ecode2)) {
57887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57888 }
57889 arg2 = static_cast< bool >(val2);
57890 {
57891 PyThreadState* __tstate = wxPyBeginAllowThreads();
57892 (arg1)->SetDone(arg2);
57893 wxPyEndAllowThreads(__tstate);
57894 if (PyErr_Occurred()) SWIG_fail;
57895 }
57896 resultobj = SWIG_Py_Void();
57897 return resultobj;
57898 fail:
57899 return NULL;
57900 }
57901
57902
57903 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57904 PyObject *resultobj = 0;
57905 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57906 wxRelationship result;
57907 void *argp1 = 0 ;
57908 int res1 = 0 ;
57909 PyObject *swig_obj[1] ;
57910
57911 if (!args) SWIG_fail;
57912 swig_obj[0] = args;
57913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57914 if (!SWIG_IsOK(res1)) {
57915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57916 }
57917 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57918 {
57919 PyThreadState* __tstate = wxPyBeginAllowThreads();
57920 result = (wxRelationship)(arg1)->GetRelationship();
57921 wxPyEndAllowThreads(__tstate);
57922 if (PyErr_Occurred()) SWIG_fail;
57923 }
57924 resultobj = SWIG_From_int(static_cast< int >(result));
57925 return resultobj;
57926 fail:
57927 return NULL;
57928 }
57929
57930
57931 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57932 PyObject *resultobj = 0;
57933 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57934 wxRelationship arg2 ;
57935 void *argp1 = 0 ;
57936 int res1 = 0 ;
57937 int val2 ;
57938 int ecode2 = 0 ;
57939 PyObject * obj0 = 0 ;
57940 PyObject * obj1 = 0 ;
57941 char * kwnames[] = {
57942 (char *) "self",(char *) "r", NULL
57943 };
57944
57945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57947 if (!SWIG_IsOK(res1)) {
57948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57949 }
57950 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57951 ecode2 = SWIG_AsVal_int(obj1, &val2);
57952 if (!SWIG_IsOK(ecode2)) {
57953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57954 }
57955 arg2 = static_cast< wxRelationship >(val2);
57956 {
57957 PyThreadState* __tstate = wxPyBeginAllowThreads();
57958 (arg1)->SetRelationship(arg2);
57959 wxPyEndAllowThreads(__tstate);
57960 if (PyErr_Occurred()) SWIG_fail;
57961 }
57962 resultobj = SWIG_Py_Void();
57963 return resultobj;
57964 fail:
57965 return NULL;
57966 }
57967
57968
57969 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57970 PyObject *resultobj = 0;
57971 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57972 wxWindow *arg2 = (wxWindow *) 0 ;
57973 bool result;
57974 void *argp1 = 0 ;
57975 int res1 = 0 ;
57976 void *argp2 = 0 ;
57977 int res2 = 0 ;
57978 PyObject * obj0 = 0 ;
57979 PyObject * obj1 = 0 ;
57980 char * kwnames[] = {
57981 (char *) "self",(char *) "otherW", NULL
57982 };
57983
57984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57986 if (!SWIG_IsOK(res1)) {
57987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57988 }
57989 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57991 if (!SWIG_IsOK(res2)) {
57992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57993 }
57994 arg2 = reinterpret_cast< wxWindow * >(argp2);
57995 {
57996 PyThreadState* __tstate = wxPyBeginAllowThreads();
57997 result = (bool)(arg1)->ResetIfWin(arg2);
57998 wxPyEndAllowThreads(__tstate);
57999 if (PyErr_Occurred()) SWIG_fail;
58000 }
58001 {
58002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58003 }
58004 return resultobj;
58005 fail:
58006 return NULL;
58007 }
58008
58009
58010 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58011 PyObject *resultobj = 0;
58012 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
58013 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
58014 wxWindow *arg3 = (wxWindow *) 0 ;
58015 bool result;
58016 void *argp1 = 0 ;
58017 int res1 = 0 ;
58018 void *argp2 = 0 ;
58019 int res2 = 0 ;
58020 void *argp3 = 0 ;
58021 int res3 = 0 ;
58022 PyObject * obj0 = 0 ;
58023 PyObject * obj1 = 0 ;
58024 PyObject * obj2 = 0 ;
58025 char * kwnames[] = {
58026 (char *) "self",(char *) "constraints",(char *) "win", NULL
58027 };
58028
58029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
58030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58031 if (!SWIG_IsOK(res1)) {
58032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
58033 }
58034 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
58035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58036 if (!SWIG_IsOK(res2)) {
58037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
58038 }
58039 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
58040 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
58041 if (!SWIG_IsOK(res3)) {
58042 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
58043 }
58044 arg3 = reinterpret_cast< wxWindow * >(argp3);
58045 {
58046 PyThreadState* __tstate = wxPyBeginAllowThreads();
58047 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
58048 wxPyEndAllowThreads(__tstate);
58049 if (PyErr_Occurred()) SWIG_fail;
58050 }
58051 {
58052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58053 }
58054 return resultobj;
58055 fail:
58056 return NULL;
58057 }
58058
58059
58060 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58061 PyObject *resultobj = 0;
58062 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
58063 wxEdge arg2 ;
58064 wxWindow *arg3 = (wxWindow *) 0 ;
58065 wxWindow *arg4 = (wxWindow *) 0 ;
58066 int result;
58067 void *argp1 = 0 ;
58068 int res1 = 0 ;
58069 int val2 ;
58070 int ecode2 = 0 ;
58071 void *argp3 = 0 ;
58072 int res3 = 0 ;
58073 void *argp4 = 0 ;
58074 int res4 = 0 ;
58075 PyObject * obj0 = 0 ;
58076 PyObject * obj1 = 0 ;
58077 PyObject * obj2 = 0 ;
58078 PyObject * obj3 = 0 ;
58079 char * kwnames[] = {
58080 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
58081 };
58082
58083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
58084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58085 if (!SWIG_IsOK(res1)) {
58086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
58087 }
58088 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
58089 ecode2 = SWIG_AsVal_int(obj1, &val2);
58090 if (!SWIG_IsOK(ecode2)) {
58091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
58092 }
58093 arg2 = static_cast< wxEdge >(val2);
58094 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
58095 if (!SWIG_IsOK(res3)) {
58096 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
58097 }
58098 arg3 = reinterpret_cast< wxWindow * >(argp3);
58099 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
58100 if (!SWIG_IsOK(res4)) {
58101 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
58102 }
58103 arg4 = reinterpret_cast< wxWindow * >(argp4);
58104 {
58105 PyThreadState* __tstate = wxPyBeginAllowThreads();
58106 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
58107 wxPyEndAllowThreads(__tstate);
58108 if (PyErr_Occurred()) SWIG_fail;
58109 }
58110 resultobj = SWIG_From_int(static_cast< int >(result));
58111 return resultobj;
58112 fail:
58113 return NULL;
58114 }
58115
58116
58117 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58118 PyObject *obj;
58119 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58120 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
58121 return SWIG_Py_Void();
58122 }
58123
58124 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58125 PyObject *resultobj = 0;
58126 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58127 wxIndividualLayoutConstraint *result = 0 ;
58128 void *argp1 = 0 ;
58129 int res1 = 0 ;
58130 PyObject *swig_obj[1] ;
58131
58132 if (!args) SWIG_fail;
58133 swig_obj[0] = args;
58134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58135 if (!SWIG_IsOK(res1)) {
58136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58137 }
58138 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58139 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
58140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58141 return resultobj;
58142 fail:
58143 return NULL;
58144 }
58145
58146
58147 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58148 PyObject *resultobj = 0;
58149 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58150 wxIndividualLayoutConstraint *result = 0 ;
58151 void *argp1 = 0 ;
58152 int res1 = 0 ;
58153 PyObject *swig_obj[1] ;
58154
58155 if (!args) SWIG_fail;
58156 swig_obj[0] = args;
58157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58158 if (!SWIG_IsOK(res1)) {
58159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58160 }
58161 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58162 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
58163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58164 return resultobj;
58165 fail:
58166 return NULL;
58167 }
58168
58169
58170 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58171 PyObject *resultobj = 0;
58172 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58173 wxIndividualLayoutConstraint *result = 0 ;
58174 void *argp1 = 0 ;
58175 int res1 = 0 ;
58176 PyObject *swig_obj[1] ;
58177
58178 if (!args) SWIG_fail;
58179 swig_obj[0] = args;
58180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58181 if (!SWIG_IsOK(res1)) {
58182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58183 }
58184 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58185 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
58186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58187 return resultobj;
58188 fail:
58189 return NULL;
58190 }
58191
58192
58193 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58194 PyObject *resultobj = 0;
58195 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58196 wxIndividualLayoutConstraint *result = 0 ;
58197 void *argp1 = 0 ;
58198 int res1 = 0 ;
58199 PyObject *swig_obj[1] ;
58200
58201 if (!args) SWIG_fail;
58202 swig_obj[0] = args;
58203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58204 if (!SWIG_IsOK(res1)) {
58205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58206 }
58207 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58208 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
58209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58210 return resultobj;
58211 fail:
58212 return NULL;
58213 }
58214
58215
58216 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58217 PyObject *resultobj = 0;
58218 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58219 wxIndividualLayoutConstraint *result = 0 ;
58220 void *argp1 = 0 ;
58221 int res1 = 0 ;
58222 PyObject *swig_obj[1] ;
58223
58224 if (!args) SWIG_fail;
58225 swig_obj[0] = args;
58226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58227 if (!SWIG_IsOK(res1)) {
58228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58229 }
58230 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58231 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
58232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58233 return resultobj;
58234 fail:
58235 return NULL;
58236 }
58237
58238
58239 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58240 PyObject *resultobj = 0;
58241 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58242 wxIndividualLayoutConstraint *result = 0 ;
58243 void *argp1 = 0 ;
58244 int res1 = 0 ;
58245 PyObject *swig_obj[1] ;
58246
58247 if (!args) SWIG_fail;
58248 swig_obj[0] = args;
58249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58250 if (!SWIG_IsOK(res1)) {
58251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58252 }
58253 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58254 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
58255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58256 return resultobj;
58257 fail:
58258 return NULL;
58259 }
58260
58261
58262 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58263 PyObject *resultobj = 0;
58264 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58265 wxIndividualLayoutConstraint *result = 0 ;
58266 void *argp1 = 0 ;
58267 int res1 = 0 ;
58268 PyObject *swig_obj[1] ;
58269
58270 if (!args) SWIG_fail;
58271 swig_obj[0] = args;
58272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58273 if (!SWIG_IsOK(res1)) {
58274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58275 }
58276 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58277 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
58278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58279 return resultobj;
58280 fail:
58281 return NULL;
58282 }
58283
58284
58285 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58286 PyObject *resultobj = 0;
58287 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58288 wxIndividualLayoutConstraint *result = 0 ;
58289 void *argp1 = 0 ;
58290 int res1 = 0 ;
58291 PyObject *swig_obj[1] ;
58292
58293 if (!args) SWIG_fail;
58294 swig_obj[0] = args;
58295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58296 if (!SWIG_IsOK(res1)) {
58297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58298 }
58299 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58300 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
58301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58302 return resultobj;
58303 fail:
58304 return NULL;
58305 }
58306
58307
58308 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58309 PyObject *resultobj = 0;
58310 wxLayoutConstraints *result = 0 ;
58311
58312 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
58313 {
58314 PyThreadState* __tstate = wxPyBeginAllowThreads();
58315 result = (wxLayoutConstraints *)new wxLayoutConstraints();
58316 wxPyEndAllowThreads(__tstate);
58317 if (PyErr_Occurred()) SWIG_fail;
58318 }
58319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
58320 return resultobj;
58321 fail:
58322 return NULL;
58323 }
58324
58325
58326 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58327 PyObject *resultobj = 0;
58328 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58329 void *argp1 = 0 ;
58330 int res1 = 0 ;
58331 PyObject *swig_obj[1] ;
58332
58333 if (!args) SWIG_fail;
58334 swig_obj[0] = args;
58335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
58336 if (!SWIG_IsOK(res1)) {
58337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58338 }
58339 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58340 {
58341 PyThreadState* __tstate = wxPyBeginAllowThreads();
58342 delete arg1;
58343
58344 wxPyEndAllowThreads(__tstate);
58345 if (PyErr_Occurred()) SWIG_fail;
58346 }
58347 resultobj = SWIG_Py_Void();
58348 return resultobj;
58349 fail:
58350 return NULL;
58351 }
58352
58353
58354 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58355 PyObject *resultobj = 0;
58356 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58357 wxWindow *arg2 = (wxWindow *) 0 ;
58358 int *arg3 = (int *) 0 ;
58359 bool result;
58360 void *argp1 = 0 ;
58361 int res1 = 0 ;
58362 void *argp2 = 0 ;
58363 int res2 = 0 ;
58364 int temp3 ;
58365 int res3 = SWIG_TMPOBJ ;
58366 PyObject * obj0 = 0 ;
58367 PyObject * obj1 = 0 ;
58368 char * kwnames[] = {
58369 (char *) "self",(char *) "win", NULL
58370 };
58371
58372 arg3 = &temp3;
58373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
58374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58375 if (!SWIG_IsOK(res1)) {
58376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58377 }
58378 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
58380 if (!SWIG_IsOK(res2)) {
58381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
58382 }
58383 arg2 = reinterpret_cast< wxWindow * >(argp2);
58384 {
58385 PyThreadState* __tstate = wxPyBeginAllowThreads();
58386 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
58387 wxPyEndAllowThreads(__tstate);
58388 if (PyErr_Occurred()) SWIG_fail;
58389 }
58390 {
58391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58392 }
58393 if (SWIG_IsTmpObj(res3)) {
58394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
58395 } else {
58396 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
58398 }
58399 return resultobj;
58400 fail:
58401 return NULL;
58402 }
58403
58404
58405 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58406 PyObject *resultobj = 0;
58407 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58408 bool result;
58409 void *argp1 = 0 ;
58410 int res1 = 0 ;
58411 PyObject *swig_obj[1] ;
58412
58413 if (!args) SWIG_fail;
58414 swig_obj[0] = args;
58415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58416 if (!SWIG_IsOK(res1)) {
58417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
58418 }
58419 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58420 {
58421 PyThreadState* __tstate = wxPyBeginAllowThreads();
58422 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
58423 wxPyEndAllowThreads(__tstate);
58424 if (PyErr_Occurred()) SWIG_fail;
58425 }
58426 {
58427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58428 }
58429 return resultobj;
58430 fail:
58431 return NULL;
58432 }
58433
58434
58435 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58436 PyObject *obj;
58437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58438 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
58439 return SWIG_Py_Void();
58440 }
58441
58442 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58443 return SWIG_Python_InitShadowInstance(args);
58444 }
58445
58446 static PyMethodDef SwigMethods[] = {
58447 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
58448 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
58449 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
58450 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
58451 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
58452 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
58453 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
58454 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
58455 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
58456 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58457 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
58458 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58459 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58460 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58461 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58462 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
58463 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
58464 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
58465 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
58466 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58467 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58468 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58469 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58470 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
58471 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
58472 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
58473 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
58474 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
58475 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
58476 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
58477 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
58478 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
58479 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
58480 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
58481 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58482 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
58483 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58484 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58485 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58486 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58487 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58488 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
58489 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
58490 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
58491 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
58492 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
58493 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
58494 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
58495 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
58496 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
58497 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58498 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58499 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58500 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58501 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58502 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58503 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58504 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
58505 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
58506 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
58507 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
58508 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
58509 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
58510 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
58511 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
58512 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
58513 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
58514 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
58515 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
58516 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
58517 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58518 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
58519 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58520 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
58521 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58522 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
58523 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58524 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
58525 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
58526 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58527 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
58528 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
58529 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
58530 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
58531 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
58532 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58533 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
58534 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
58535 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
58536 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
58537 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58538 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58539 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58540 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58541 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
58542 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
58543 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
58544 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58545 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58546 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58547 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58548 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58549 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58550 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58551 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
58552 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58553 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58554 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58555 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
58556 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
58557 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
58558 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
58559 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
58560 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
58561 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
58562 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
58563 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
58564 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58565 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
58566 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
58567 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
58568 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
58569 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
58570 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
58571 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58572 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
58573 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
58574 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
58575 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
58576 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
58577 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
58578 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
58579 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
58580 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
58581 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58582 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58583 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
58584 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58585 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58586 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
58587 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
58588 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58589 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58590 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
58591 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
58592 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
58593 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
58594 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58595 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
58596 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
58597 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
58598 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
58599 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
58600 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
58601 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
58602 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
58603 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58604 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
58605 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
58606 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58607 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58608 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
58609 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58610 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58611 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
58612 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58613 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
58614 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
58615 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
58616 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58617 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
58618 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58619 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58620 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
58621 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
58622 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58623 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
58624 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58625 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58626 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
58627 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
58628 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
58629 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
58630 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58631 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58632 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
58633 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58634 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
58635 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58636 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
58637 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
58638 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58639 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58640 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58641 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58642 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
58643 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
58644 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58645 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58646 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
58647 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
58648 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
58649 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
58650 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
58651 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
58652 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
58653 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
58654 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58655 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
58656 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
58657 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
58658 { (char *)"new_Position", (PyCFunction) _wrap_new_Position, METH_VARARGS | METH_KEYWORDS, NULL},
58659 { (char *)"delete_Position", (PyCFunction)_wrap_delete_Position, METH_O, NULL},
58660 { (char *)"Position_GetRow", (PyCFunction)_wrap_Position_GetRow, METH_O, NULL},
58661 { (char *)"Position_GetColumn", (PyCFunction)_wrap_Position_GetColumn, METH_O, NULL},
58662 { (char *)"Position_GetCol", (PyCFunction)_wrap_Position_GetCol, METH_O, NULL},
58663 { (char *)"Position_SetRow", (PyCFunction) _wrap_Position_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
58664 { (char *)"Position_SetColumn", (PyCFunction) _wrap_Position_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
58665 { (char *)"Position_SetCol", (PyCFunction) _wrap_Position_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
58666 { (char *)"Position___eq__", (PyCFunction) _wrap_Position___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58667 { (char *)"Position___ne__", (PyCFunction) _wrap_Position___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58668 { (char *)"Position___add__", _wrap_Position___add__, METH_VARARGS, NULL},
58669 { (char *)"Position___sub__", _wrap_Position___sub__, METH_VARARGS, NULL},
58670 { (char *)"Position_swigregister", Position_swigregister, METH_VARARGS, NULL},
58671 { (char *)"Position_swiginit", Position_swiginit, METH_VARARGS, NULL},
58672 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
58673 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
58674 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
58675 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
58676 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
58677 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
58678 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
58679 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
58680 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
58681 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
58682 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
58683 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
58684 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
58685 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
58686 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
58687 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
58688 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
58689 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
58690 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
58691 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
58692 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
58693 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
58694 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
58695 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
58696 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
58697 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
58698 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
58699 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
58700 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
58701 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
58702 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
58703 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
58704 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
58705 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
58706 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
58707 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
58708 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58709 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58710 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58711 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58712 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
58713 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
58714 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58715 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
58716 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58717 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
58718 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
58719 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
58720 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
58721 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
58722 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
58723 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
58724 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58725 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58726 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
58727 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58728 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58729 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
58730 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
58731 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
58732 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
58733 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
58734 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
58735 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58737 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
58738 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
58739 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58740 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58741 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58742 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58743 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58744 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58745 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58746 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58747 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58748 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58749 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58750 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58751 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58752 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58753 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58754 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58755 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58756 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58757 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58758 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58759 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58760 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58761 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58762 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58763 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58764 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58765 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58766 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58767 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58768 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58769 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58770 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58771 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58772 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58773 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58774 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58775 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58776 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58777 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58778 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58779 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58780 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58781 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58782 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58783 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58784 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58785 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58786 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58787 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58788 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58789 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58790 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58791 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58792 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58793 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58794 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58795 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58796 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58797 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58798 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58799 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58800 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58801 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58802 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58803 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58804 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58805 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58806 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58807 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58808 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58809 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58810 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58811 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58812 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58813 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58814 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58815 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58816 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58817 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58818 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58819 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58820 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58821 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58822 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58823 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58824 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58825 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58826 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58827 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58828 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58829 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58830 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58831 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58832 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58833 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58834 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58835 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58836 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58837 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58838 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58839 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58841 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58842 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58843 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58844 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58845 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58846 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58847 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58848 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58849 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58850 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58851 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58852 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58853 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58854 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58855 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58856 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58857 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58858 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58859 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58860 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58861 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58862 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58863 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58864 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58865 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58866 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58867 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58868 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58869 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58870 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58871 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58872 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58873 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58874 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58875 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58876 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58877 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58878 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58879 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58880 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58881 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58882 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58883 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58884 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58885 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58886 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58887 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58888 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58889 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58890 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58891 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58892 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58893 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58894 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58895 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58896 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58897 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58898 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58899 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58900 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58901 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58902 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58903 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58904 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58905 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58906 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58907 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58908 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58909 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58910 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58911 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58912 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58913 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58914 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58915 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58916 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58917 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58918 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58919 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58920 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58921 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58922 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58923 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58924 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58925 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58926 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58927 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58928 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58929 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58930 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58931 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58932 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58933 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58934 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58935 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58936 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58937 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58938 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58939 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58941 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58942 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58943 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58944 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58945 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58946 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58947 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58948 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58949 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58950 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58951 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58952 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58953 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58954 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58955 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58956 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58957 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58958 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58959 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58960 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58961 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58962 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58963 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58964 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58965 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58966 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58967 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58968 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58969 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58970 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58971 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58972 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58973 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58974 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58975 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58976 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58977 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58978 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58979 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58980 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58981 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58982 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58983 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58984 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58985 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58986 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58987 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58988 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58989 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58990 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58991 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58992 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58993 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58994 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58995 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58996 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58997 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58998 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58999 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
59000 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59001 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59002 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
59003 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
59004 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59005 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
59006 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
59007 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
59008 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
59009 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
59010 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
59011 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
59012 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
59013 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
59014 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
59015 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
59016 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
59017 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
59018 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
59019 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
59020 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
59021 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
59022 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
59023 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
59024 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
59025 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
59026 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
59027 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
59028 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
59029 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
59030 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
59031 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
59032 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
59033 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
59034 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
59035 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59036 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
59037 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
59038 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
59039 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
59040 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
59041 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
59042 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
59043 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
59044 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
59045 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
59046 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
59047 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
59048 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
59049 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
59050 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
59051 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
59052 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
59053 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
59054 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
59055 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
59056 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
59057 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
59058 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
59059 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
59060 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
59061 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
59062 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
59063 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
59064 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
59065 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
59066 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
59067 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
59068 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
59069 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59070 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
59071 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
59072 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59073 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
59074 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
59075 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
59076 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
59077 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59078 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
59079 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
59080 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
59081 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
59082 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
59083 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
59084 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
59085 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
59086 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
59087 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
59088 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
59089 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
59090 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
59091 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
59092 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
59093 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
59094 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
59095 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
59096 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
59097 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
59098 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
59099 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
59100 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
59101 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
59102 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
59103 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
59104 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
59105 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
59106 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
59107 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
59108 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
59109 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
59110 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
59111 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
59112 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
59113 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
59114 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
59115 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
59116 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59117 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
59118 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
59119 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59120 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59121 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
59122 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
59123 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
59124 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
59125 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
59126 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
59127 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59128 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
59129 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
59130 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59131 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59132 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
59133 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
59134 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59135 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
59136 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
59137 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59138 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
59139 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
59140 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59141 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
59142 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
59143 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
59144 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59145 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
59146 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59147 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
59148 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
59149 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59150 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
59151 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
59152 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
59153 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59154 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
59155 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
59156 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
59157 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59158 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
59159 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
59160 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59161 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
59162 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
59163 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
59164 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
59165 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
59166 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59167 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
59168 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
59169 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
59170 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
59171 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
59172 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
59173 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
59174 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
59175 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59176 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
59177 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
59178 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
59179 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
59180 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59181 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
59182 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
59183 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
59184 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59185 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
59186 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
59187 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
59188 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
59189 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
59190 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
59191 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59192 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
59193 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
59194 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
59195 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
59196 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
59197 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
59198 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
59199 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
59200 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59201 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59202 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59203 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59204 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
59205 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
59206 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
59207 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
59208 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59209 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
59210 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
59211 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
59212 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
59213 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
59214 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
59215 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59216 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
59217 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
59218 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
59219 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59220 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
59221 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
59222 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
59223 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
59224 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
59225 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59226 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59227 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
59228 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
59229 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
59230 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59231 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
59232 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
59233 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
59234 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
59235 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
59236 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
59237 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59238 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
59239 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
59240 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
59241 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
59242 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59243 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
59244 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59245 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
59246 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
59247 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59248 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
59249 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
59250 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
59251 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59252 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
59253 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
59254 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
59255 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59256 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
59257 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59258 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
59259 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
59260 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
59261 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
59262 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
59263 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59264 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
59265 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
59266 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
59267 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
59268 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59269 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
59270 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
59271 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59272 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
59273 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59274 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
59275 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
59276 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
59277 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59278 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
59279 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59280 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
59281 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
59282 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
59283 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59284 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
59285 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
59286 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
59287 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
59288 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
59289 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
59290 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
59291 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
59292 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
59293 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
59294 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
59295 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59296 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
59297 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
59298 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
59299 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
59300 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
59301 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
59302 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
59303 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
59304 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
59305 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
59306 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
59307 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
59308 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
59309 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
59310 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
59311 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
59312 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
59313 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
59314 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
59315 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
59316 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59317 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
59318 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
59319 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
59320 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
59321 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
59322 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
59323 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
59324 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
59325 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
59326 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
59327 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
59328 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
59329 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
59330 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
59331 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
59332 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59333 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59334 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59335 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
59336 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
59337 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
59338 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
59339 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
59340 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
59341 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
59342 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
59343 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
59344 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
59345 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
59346 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59347 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
59348 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
59349 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
59350 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
59351 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
59352 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
59353 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
59354 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
59355 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
59356 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
59357 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
59358 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
59359 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
59360 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
59361 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
59362 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
59363 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
59364 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
59365 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
59366 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
59367 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
59368 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59369 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59370 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
59371 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
59372 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
59373 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
59374 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
59375 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
59376 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
59377 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
59378 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59379 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
59380 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
59381 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
59382 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
59383 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
59384 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
59385 { (char *)"VisualAttributes__get_font", (PyCFunction)_wrap_VisualAttributes__get_font, METH_O, NULL},
59386 { (char *)"VisualAttributes__get_colFg", (PyCFunction)_wrap_VisualAttributes__get_colFg, METH_O, NULL},
59387 { (char *)"VisualAttributes__get_colBg", (PyCFunction)_wrap_VisualAttributes__get_colBg, METH_O, NULL},
59388 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
59389 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
59390 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
59391 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
59392 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59393 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
59394 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
59395 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
59396 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
59397 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59398 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
59399 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
59400 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
59401 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
59402 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
59403 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59404 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
59405 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
59406 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59407 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59408 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
59409 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59410 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59411 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59412 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
59413 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59414 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59415 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
59416 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
59417 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
59418 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
59419 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
59420 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
59421 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59422 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
59423 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
59424 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
59425 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
59426 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
59427 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
59428 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
59429 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
59430 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
59431 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
59432 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
59433 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
59434 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
59435 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
59436 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
59437 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
59438 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
59439 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
59440 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
59441 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
59442 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
59443 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
59444 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59445 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59446 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59447 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59448 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
59449 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
59450 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59451 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
59452 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
59453 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
59454 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
59455 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
59456 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
59457 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59458 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
59459 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
59460 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
59461 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
59462 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59463 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
59464 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59465 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
59466 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
59467 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
59468 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
59469 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
59470 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59471 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
59472 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59473 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
59474 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59475 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59476 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
59477 { (char *)"Window_HasExtraStyle", (PyCFunction) _wrap_Window_HasExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59478 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
59479 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59480 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
59481 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
59482 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
59483 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
59484 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
59485 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
59486 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
59487 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
59488 { (char *)"Window_SetCanFocus", (PyCFunction) _wrap_Window_SetCanFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59489 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
59490 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
59491 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59492 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59493 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
59494 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
59495 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
59496 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
59497 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
59498 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
59499 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
59500 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
59501 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
59502 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59503 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59504 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
59505 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59506 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59507 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59508 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59509 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
59510 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
59511 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
59512 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
59513 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
59514 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
59515 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59516 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
59517 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59518 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59519 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59520 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59521 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
59522 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
59523 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59524 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59525 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
59526 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
59527 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
59528 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
59529 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
59530 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
59531 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
59532 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
59533 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
59534 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
59535 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
59536 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
59537 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
59538 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
59539 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
59540 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
59541 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
59542 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59543 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
59544 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
59545 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59546 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59547 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59548 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59549 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59550 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
59551 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
59552 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
59553 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
59554 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59555 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
59556 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
59557 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59558 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
59559 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59560 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
59561 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
59562 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
59563 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
59564 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
59565 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
59566 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59567 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59568 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
59569 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
59570 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
59571 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
59572 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
59573 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
59574 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
59575 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
59576 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
59577 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59578 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
59579 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
59580 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
59581 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
59582 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
59583 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59584 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59585 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59586 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59587 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
59588 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
59589 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59590 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
59591 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
59592 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
59593 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
59594 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
59595 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
59596 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
59597 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
59598 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59599 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
59600 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
59601 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
59602 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
59603 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
59604 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
59605 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
59606 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59607 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
59608 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
59609 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
59610 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
59611 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59612 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
59613 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
59614 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59615 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
59616 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
59617 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
59618 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
59619 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
59620 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
59621 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
59622 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59623 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59624 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59625 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
59626 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
59627 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
59628 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
59629 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
59630 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
59631 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
59632 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
59633 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59634 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
59635 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
59636 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
59637 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
59638 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
59639 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59640 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
59641 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
59642 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
59643 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59644 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
59645 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59646 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59647 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59648 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59649 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
59650 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59651 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59652 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
59653 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59654 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
59655 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59656 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59657 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59658 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59659 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
59660 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59661 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59662 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59663 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59664 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
59665 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59666 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
59667 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
59668 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
59669 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
59670 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
59671 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
59672 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
59673 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59674 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59675 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59676 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59677 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59678 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59679 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59680 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59681 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59682 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59683 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
59684 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
59685 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59686 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
59687 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59688 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
59689 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
59690 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
59691 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
59692 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59693 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
59694 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
59695 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
59696 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
59697 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
59698 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
59699 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
59700 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59701 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59702 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
59703 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59704 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
59705 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59706 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
59707 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
59708 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59709 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59710 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59711 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59712 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59713 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59714 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59715 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59716 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59717 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59718 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59719 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59720 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59721 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
59722 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
59723 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59724 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
59725 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
59726 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59727 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
59728 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
59729 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
59730 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59731 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
59732 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
59733 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59734 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59735 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
59736 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
59737 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59738 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59739 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59740 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59741 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59742 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59743 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59744 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59745 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59746 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59747 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59748 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59749 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59750 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59751 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59752 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59753 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59754 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59755 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59756 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59757 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59758 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59759 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59760 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59761 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59762 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59763 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59764 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59765 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59766 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59767 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59768 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59769 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59770 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59771 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59772 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59773 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59774 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59775 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59776 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59777 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59778 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59779 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59780 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59781 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59782 { (char *)"Control_RemoveMnemonics", (PyCFunction) _wrap_Control_RemoveMnemonics, METH_VARARGS | METH_KEYWORDS, NULL},
59783 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59784 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59785 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59786 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59787 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59788 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59789 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59790 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59791 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59792 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59793 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59794 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59795 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59796 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59797 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59798 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59799 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59800 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59801 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59802 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59803 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59804 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59805 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59806 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59807 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59808 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59809 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59810 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59811 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59812 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59813 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59814 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59815 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59816 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59817 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59818 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59819 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59820 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59821 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59822 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59823 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59824 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59825 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59826 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59827 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59828 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59829 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59830 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59831 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59832 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59833 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59834 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59835 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59836 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59837 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59838 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59839 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59840 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59841 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59842 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59843 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59844 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59845 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59846 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59847 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59848 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59849 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59850 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59851 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59852 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59853 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59854 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59855 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59856 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59857 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59858 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59859 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59860 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59861 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59862 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59863 { (char *)"SizerItem_AssignWindow", (PyCFunction) _wrap_SizerItem_AssignWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59864 { (char *)"SizerItem_AssignSizer", (PyCFunction) _wrap_SizerItem_AssignSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59865 { (char *)"SizerItem_AssignSpacer", (PyCFunction) _wrap_SizerItem_AssignSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59866 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59867 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59868 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59869 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59870 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59871 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59872 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59873 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59874 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59875 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59876 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59877 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59878 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59879 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59880 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59881 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59882 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59883 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59884 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59885 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59886 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59887 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59888 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59889 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59890 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59891 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59892 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59893 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59894 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59895 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59896 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59897 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59898 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59899 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59900 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59901 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59902 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59903 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59904 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59905 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59906 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59907 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59908 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59909 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59910 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59911 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59912 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59913 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59914 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59915 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59916 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59917 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59918 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59919 { (char *)"BoxSizer_IsVertical", (PyCFunction)_wrap_BoxSizer_IsVertical, METH_O, NULL},
59920 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59921 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59922 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59923 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59924 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59925 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59926 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59927 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59928 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59929 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59930 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59931 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59932 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59933 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59934 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59935 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59936 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59937 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59938 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59939 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59940 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59941 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59942 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59943 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59944 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59945 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59946 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59947 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59948 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59949 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59950 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59951 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59952 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59953 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59954 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59955 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59956 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59957 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59958 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59959 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59960 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59961 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59962 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59963 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59964 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59965 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59966 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59967 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59968 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59969 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59970 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59971 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59972 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59973 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59974 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59975 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59976 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59977 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59978 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59979 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59980 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59981 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59982 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59983 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59984 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59985 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59986 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59987 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59988 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59989 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59990 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59991 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59992 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59993 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59994 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59995 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59996 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59997 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59998 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59999 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
60000 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
60001 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
60002 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
60003 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
60004 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
60005 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
60006 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
60007 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
60008 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
60009 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
60010 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
60011 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
60012 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
60013 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
60014 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
60015 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
60016 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
60017 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
60018 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
60019 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
60020 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
60021 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
60022 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
60023 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
60024 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
60025 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
60026 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
60027 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
60028 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
60029 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
60030 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
60031 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
60032 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
60033 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
60034 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
60035 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
60036 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
60037 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
60038 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
60039 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
60040 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
60041 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
60042 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
60043 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
60044 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
60045 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
60046 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
60047 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
60048 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
60049 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
60050 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
60051 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
60052 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
60053 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
60054 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
60055 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
60056 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
60057 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
60058 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
60059 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
60060 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
60061 { NULL, NULL, 0, NULL }
60062 };
60063
60064
60065 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
60066
60067 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
60068 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
60069 }
60070 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
60071 return (void *)((wxEvent *) ((wxMenuEvent *) x));
60072 }
60073 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
60074 return (void *)((wxEvent *) ((wxCloseEvent *) x));
60075 }
60076 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
60077 return (void *)((wxEvent *) ((wxMouseEvent *) x));
60078 }
60079 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
60080 return (void *)((wxEvent *) ((wxEraseEvent *) x));
60081 }
60082 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
60083 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
60084 }
60085 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
60086 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
60087 }
60088 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
60089 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
60090 }
60091 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
60092 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
60093 }
60094 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
60095 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
60096 }
60097 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
60098 return (void *)((wxEvent *) ((wxPyEvent *) x));
60099 }
60100 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
60101 return (void *)((wxEvent *) ((wxIdleEvent *) x));
60102 }
60103 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
60104 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
60105 }
60106 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
60107 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
60108 }
60109 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
60110 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
60111 }
60112 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
60113 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
60114 }
60115 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
60116 return (void *)((wxEvent *) ((wxActivateEvent *) x));
60117 }
60118 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
60119 return (void *)((wxEvent *) ((wxSizeEvent *) x));
60120 }
60121 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
60122 return (void *)((wxEvent *) ((wxMoveEvent *) x));
60123 }
60124 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
60125 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
60126 }
60127 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
60128 return (void *)((wxEvent *) ((wxPaintEvent *) x));
60129 }
60130 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
60131 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
60132 }
60133 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
60134 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
60135 }
60136 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
60137 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
60138 }
60139 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
60140 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
60141 }
60142 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
60143 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
60144 }
60145 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
60146 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60147 }
60148 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
60149 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
60150 }
60151 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
60152 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
60153 }
60154 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
60155 return (void *)((wxEvent *) ((wxFocusEvent *) x));
60156 }
60157 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
60158 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
60159 }
60160 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
60161 return (void *)((wxEvent *) ((wxShowEvent *) x));
60162 }
60163 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
60164 return (void *)((wxEvent *) ((wxCommandEvent *) x));
60165 }
60166 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
60167 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
60168 }
60169 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
60170 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60171 }
60172 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
60173 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
60174 }
60175 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
60176 return (void *)((wxEvent *) ((wxKeyEvent *) x));
60177 }
60178 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
60179 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
60180 }
60181 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
60182 return (void *)((wxValidator *) ((wxPyValidator *) x));
60183 }
60184 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
60185 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
60186 }
60187 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
60188 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
60189 }
60190 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
60191 return (void *)((wxObject *) ((wxSizerItem *) x));
60192 }
60193 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
60194 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
60195 }
60196 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
60197 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
60198 }
60199 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
60200 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
60201 }
60202 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
60203 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
60204 }
60205 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
60206 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
60207 }
60208 static void *_p_wxSizerTo_p_wxObject(void *x) {
60209 return (void *)((wxObject *) ((wxSizer *) x));
60210 }
60211 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
60212 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60213 }
60214 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
60215 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
60216 }
60217 static void *_p_wxEventTo_p_wxObject(void *x) {
60218 return (void *)((wxObject *) ((wxEvent *) x));
60219 }
60220 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
60221 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
60222 }
60223 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
60224 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
60225 }
60226 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
60227 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
60228 }
60229 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
60230 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
60231 }
60232 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
60233 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
60234 }
60235 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
60236 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
60237 }
60238 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
60239 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
60240 }
60241 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
60242 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
60243 }
60244 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
60245 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60246 }
60247 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
60248 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
60249 }
60250 static void *_p_wxControlTo_p_wxObject(void *x) {
60251 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
60252 }
60253 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
60254 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
60255 }
60256 static void *_p_wxFSFileTo_p_wxObject(void *x) {
60257 return (void *)((wxObject *) ((wxFSFile *) x));
60258 }
60259 static void *_p_wxPySizerTo_p_wxObject(void *x) {
60260 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
60261 }
60262 static void *_p_wxPyEventTo_p_wxObject(void *x) {
60263 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
60264 }
60265 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
60266 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
60267 }
60268 static void *_p_wxShowEventTo_p_wxObject(void *x) {
60269 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
60270 }
60271 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
60272 return (void *)((wxObject *) ((wxMenuItem *) x));
60273 }
60274 static void *_p_wxDateEventTo_p_wxObject(void *x) {
60275 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
60276 }
60277 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
60278 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
60279 }
60280 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
60281 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
60282 }
60283 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
60284 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
60285 }
60286 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
60287 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
60288 }
60289 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
60290 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
60291 }
60292 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
60293 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
60294 }
60295 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
60296 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
60297 }
60298 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
60299 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
60300 }
60301 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
60302 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
60303 }
60304 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
60305 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
60306 }
60307 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
60308 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
60309 }
60310 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
60311 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
60312 }
60313 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
60314 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
60315 }
60316 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
60317 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60318 }
60319 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
60320 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60321 }
60322 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
60323 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
60324 }
60325 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
60326 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
60327 }
60328 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
60329 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
60330 }
60331 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
60332 return (void *)((wxObject *) ((wxImageHandler *) x));
60333 }
60334 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
60335 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
60336 }
60337 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
60338 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
60339 }
60340 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
60341 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
60342 }
60343 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
60344 return (void *)((wxObject *) ((wxEvtHandler *) x));
60345 }
60346 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
60347 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
60348 }
60349 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
60350 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
60351 }
60352 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
60353 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60354 }
60355 static void *_p_wxImageTo_p_wxObject(void *x) {
60356 return (void *)((wxObject *) ((wxImage *) x));
60357 }
60358 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
60359 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
60360 }
60361 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
60362 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60363 }
60364 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
60365 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
60366 }
60367 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
60368 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
60369 }
60370 static void *_p_wxWindowTo_p_wxObject(void *x) {
60371 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
60372 }
60373 static void *_p_wxMenuTo_p_wxObject(void *x) {
60374 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
60375 }
60376 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
60377 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
60378 }
60379 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
60380 return (void *)((wxObject *) ((wxFileSystem *) x));
60381 }
60382 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
60383 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
60384 }
60385 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
60386 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
60387 }
60388 static void *_p_wxPyAppTo_p_wxObject(void *x) {
60389 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
60390 }
60391 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
60392 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
60393 }
60394 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
60395 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
60396 }
60397 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
60398 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
60399 }
60400 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
60401 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
60402 }
60403 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
60404 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
60405 }
60406 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
60407 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
60408 }
60409 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
60410 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
60411 }
60412 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
60413 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
60414 }
60415 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
60416 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60417 }
60418 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
60419 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
60420 }
60421 static void *_p_wxValidatorTo_p_wxObject(void *x) {
60422 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
60423 }
60424 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
60425 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
60426 }
60427 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
60428 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
60429 }
60430 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
60431 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
60432 }
60433 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
60434 return (void *)((wxControl *) ((wxControlWithItems *) x));
60435 }
60436 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
60437 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
60438 }
60439 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
60440 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
60441 }
60442 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
60443 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60444 }
60445 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
60446 return (void *)((wxSizer *) ((wxBoxSizer *) x));
60447 }
60448 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
60449 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
60450 }
60451 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
60452 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60453 }
60454 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
60455 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60456 }
60457 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
60458 return (void *)((wxSizer *) ((wxGridSizer *) x));
60459 }
60460 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
60461 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
60462 }
60463 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
60464 return (void *)((wxSizer *) ((wxPySizer *) x));
60465 }
60466 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
60467 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
60468 }
60469 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
60470 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
60471 }
60472 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
60473 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
60474 }
60475 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
60476 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
60477 }
60478 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
60479 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
60480 }
60481 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
60482 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
60483 }
60484 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
60485 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
60486 }
60487 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
60488 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
60489 }
60490 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
60491 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60492 }
60493 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
60494 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60495 }
60496 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
60497 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
60498 }
60499 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
60500 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
60501 }
60502 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
60503 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
60504 }
60505 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
60506 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
60507 }
60508 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
60509 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
60510 }
60511 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
60512 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
60513 }
60514 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
60515 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
60516 }
60517 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
60518 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
60519 }
60520 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
60521 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
60522 }
60523 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
60524 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
60525 }
60526 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
60527 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60528 }
60529 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
60530 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
60531 }
60532 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
60533 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
60534 }
60535 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
60536 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
60537 }
60538 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
60539 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
60540 }
60541 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
60542 return (void *)((wxEvtHandler *) ((wxWindow *) x));
60543 }
60544 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
60545 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60546 }
60547 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
60548 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
60549 }
60550 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
60551 return (void *)((wxEvtHandler *) ((wxValidator *) x));
60552 }
60553 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
60554 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
60555 }
60556 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
60557 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
60558 }
60559 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
60560 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
60561 }
60562 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
60563 return (void *)((wxEvtHandler *) ((wxMenu *) x));
60564 }
60565 static void *_p_wxControlTo_p_wxWindow(void *x) {
60566 return (void *)((wxWindow *) ((wxControl *) x));
60567 }
60568 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
60569 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
60570 }
60571 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
60572 return (void *)((wxWindow *) ((wxMenuBar *) x));
60573 }
60574 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
60575 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
60576 }
60577 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
60578 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
60579 }
60580 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
60581 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
60582 }
60583 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
60584 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
60585 }
60586 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
60587 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
60588 }
60589 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
60590 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
60591 }
60592 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
60593 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60594 }
60595 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
60596 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
60597 }
60598 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
60599 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
60600 }
60601 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
60602 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
60603 }
60604 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
60605 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
60606 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};
60607 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
60608 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
60609 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
60610 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
60611 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
60612 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
60613 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
60614 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
60615 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
60616 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
60617 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
60618 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
60619 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
60620 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
60621 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
60622 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
60623 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
60624 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
60625 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
60626 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
60627 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
60628 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
60629 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
60630 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
60631 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
60632 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
60633 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
60634 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
60635 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
60636 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
60637 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
60638 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
60639 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
60640 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
60641 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
60642 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
60643 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
60644 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
60645 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
60646 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
60647 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
60648 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
60649 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
60650 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
60651 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
60652 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
60653 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
60654 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
60655 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
60656 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
60657 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
60658 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
60659 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
60660 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
60661 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
60662 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
60663 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
60664 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
60665 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
60666 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
60667 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
60668 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
60669 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
60670 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
60671 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
60672 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
60673 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
60674 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
60675 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
60676 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
60677 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
60678 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
60679 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
60680 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
60681 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
60682 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
60683 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
60684 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
60685 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
60686 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
60687 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
60688 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
60689 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
60690 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
60691 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
60692 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
60693 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
60694 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
60695 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
60696 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
60697 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
60698 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
60699 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
60700 static swig_type_info _swigt__p_wxPosition = {"_p_wxPosition", "wxPosition *", 0, 0, (void*)0, 0};
60701 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
60702 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
60703 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
60704 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
60705 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
60706 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
60707 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
60708 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
60709 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
60710 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
60711 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
60712 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
60713 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
60714 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
60715 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
60716 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
60717 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
60718 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
60719 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
60720 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
60721 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
60722 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
60723 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
60724 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
60725 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
60726 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
60727 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
60728 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
60729 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
60730 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
60731 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
60732 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
60733 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
60734 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
60735 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
60736 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
60737 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
60738 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
60739 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
60740 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
60741 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
60742
60743 static swig_type_info *swig_type_initial[] = {
60744 &_swigt__p_buffer,
60745 &_swigt__p_char,
60746 &_swigt__p_form_ops_t,
60747 &_swigt__p_int,
60748 &_swigt__p_long,
60749 &_swigt__p_unsigned_char,
60750 &_swigt__p_unsigned_int,
60751 &_swigt__p_unsigned_long,
60752 &_swigt__p_wxANIHandler,
60753 &_swigt__p_wxAcceleratorEntry,
60754 &_swigt__p_wxAcceleratorTable,
60755 &_swigt__p_wxActivateEvent,
60756 &_swigt__p_wxAppTraits,
60757 &_swigt__p_wxArrayString,
60758 &_swigt__p_wxBMPHandler,
60759 &_swigt__p_wxBitmap,
60760 &_swigt__p_wxBoxSizer,
60761 &_swigt__p_wxButton,
60762 &_swigt__p_wxCURHandler,
60763 &_swigt__p_wxCaret,
60764 &_swigt__p_wxChildFocusEvent,
60765 &_swigt__p_wxClipboardTextEvent,
60766 &_swigt__p_wxCloseEvent,
60767 &_swigt__p_wxColour,
60768 &_swigt__p_wxCommandEvent,
60769 &_swigt__p_wxContextMenuEvent,
60770 &_swigt__p_wxControl,
60771 &_swigt__p_wxControlWithItems,
60772 &_swigt__p_wxCursor,
60773 &_swigt__p_wxDC,
60774 &_swigt__p_wxDateEvent,
60775 &_swigt__p_wxDateTime,
60776 &_swigt__p_wxDisplayChangedEvent,
60777 &_swigt__p_wxDouble,
60778 &_swigt__p_wxDropFilesEvent,
60779 &_swigt__p_wxDuplexMode,
60780 &_swigt__p_wxEraseEvent,
60781 &_swigt__p_wxEvent,
60782 &_swigt__p_wxEventBlocker,
60783 &_swigt__p_wxEventLoop,
60784 &_swigt__p_wxEventLoopActivator,
60785 &_swigt__p_wxEvtHandler,
60786 &_swigt__p_wxFSFile,
60787 &_swigt__p_wxFileSystem,
60788 &_swigt__p_wxFileSystemHandler,
60789 &_swigt__p_wxFlexGridSizer,
60790 &_swigt__p_wxFocusEvent,
60791 &_swigt__p_wxFont,
60792 &_swigt__p_wxFrame,
60793 &_swigt__p_wxGBPosition,
60794 &_swigt__p_wxGBSizerItem,
60795 &_swigt__p_wxGBSpan,
60796 &_swigt__p_wxGIFHandler,
60797 &_swigt__p_wxGridBagSizer,
60798 &_swigt__p_wxGridSizer,
60799 &_swigt__p_wxHelpEvent__Origin,
60800 &_swigt__p_wxICOHandler,
60801 &_swigt__p_wxIconizeEvent,
60802 &_swigt__p_wxIdleEvent,
60803 &_swigt__p_wxImage,
60804 &_swigt__p_wxImageHandler,
60805 &_swigt__p_wxImageHistogram,
60806 &_swigt__p_wxImage_HSVValue,
60807 &_swigt__p_wxImage_RGBValue,
60808 &_swigt__p_wxIndividualLayoutConstraint,
60809 &_swigt__p_wxInitDialogEvent,
60810 &_swigt__p_wxInputStream,
60811 &_swigt__p_wxInternetFSHandler,
60812 &_swigt__p_wxItemContainer,
60813 &_swigt__p_wxJPEGHandler,
60814 &_swigt__p_wxKeyEvent,
60815 &_swigt__p_wxLayoutConstraints,
60816 &_swigt__p_wxMaximizeEvent,
60817 &_swigt__p_wxMemoryFSHandler,
60818 &_swigt__p_wxMenu,
60819 &_swigt__p_wxMenuBar,
60820 &_swigt__p_wxMenuBarBase,
60821 &_swigt__p_wxMenuEvent,
60822 &_swigt__p_wxMenuItem,
60823 &_swigt__p_wxMouseCaptureChangedEvent,
60824 &_swigt__p_wxMouseCaptureLostEvent,
60825 &_swigt__p_wxMouseEvent,
60826 &_swigt__p_wxMoveEvent,
60827 &_swigt__p_wxNavigationKeyEvent,
60828 &_swigt__p_wxNcPaintEvent,
60829 &_swigt__p_wxNotifyEvent,
60830 &_swigt__p_wxObject,
60831 &_swigt__p_wxOutputStream,
60832 &_swigt__p_wxPCXHandler,
60833 &_swigt__p_wxPNGHandler,
60834 &_swigt__p_wxPNMHandler,
60835 &_swigt__p_wxPaintEvent,
60836 &_swigt__p_wxPaletteChangedEvent,
60837 &_swigt__p_wxPaperSize,
60838 &_swigt__p_wxPoint,
60839 &_swigt__p_wxPoint2D,
60840 &_swigt__p_wxPosition,
60841 &_swigt__p_wxPropagateOnce,
60842 &_swigt__p_wxPropagationDisabler,
60843 &_swigt__p_wxPyApp,
60844 &_swigt__p_wxPyCommandEvent,
60845 &_swigt__p_wxPyDropTarget,
60846 &_swigt__p_wxPyEvent,
60847 &_swigt__p_wxPyFileSystemHandler,
60848 &_swigt__p_wxPyImageHandler,
60849 &_swigt__p_wxPyInputStream,
60850 &_swigt__p_wxPySizer,
60851 &_swigt__p_wxPyValidator,
60852 &_swigt__p_wxQuantize,
60853 &_swigt__p_wxQueryNewPaletteEvent,
60854 &_swigt__p_wxRealPoint,
60855 &_swigt__p_wxRect,
60856 &_swigt__p_wxRect2D,
60857 &_swigt__p_wxRegion,
60858 &_swigt__p_wxScrollEvent,
60859 &_swigt__p_wxScrollWinEvent,
60860 &_swigt__p_wxSetCursorEvent,
60861 &_swigt__p_wxShowEvent,
60862 &_swigt__p_wxSize,
60863 &_swigt__p_wxSizeEvent,
60864 &_swigt__p_wxSizer,
60865 &_swigt__p_wxSizerFlags,
60866 &_swigt__p_wxSizerItem,
60867 &_swigt__p_wxStaticBox,
60868 &_swigt__p_wxStaticBoxSizer,
60869 &_swigt__p_wxStdDialogButtonSizer,
60870 &_swigt__p_wxSysColourChangedEvent,
60871 &_swigt__p_wxTGAHandler,
60872 &_swigt__p_wxTIFFHandler,
60873 &_swigt__p_wxToolTip,
60874 &_swigt__p_wxUpdateUIEvent,
60875 &_swigt__p_wxValidator,
60876 &_swigt__p_wxVisualAttributes,
60877 &_swigt__p_wxWindow,
60878 &_swigt__p_wxWindowCreateEvent,
60879 &_swigt__p_wxWindowDestroyEvent,
60880 &_swigt__p_wxXPMHandler,
60881 &_swigt__p_wxZipFSHandler,
60882 };
60883
60884 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60885 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60886 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60887 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60888 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60889 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60890 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60891 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60892 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60893 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60894 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60895 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60896 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60897 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60898 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}};
60899 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60900 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}};
60901 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60902 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}};
60903 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60904 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60905 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60906 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60907 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60908 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}};
60909 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60910 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}};
60911 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60912 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60913 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60914 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60915 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60916 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60917 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60918 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60919 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60920 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60921 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}};
60922 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60923 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60924 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60925 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
60926 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60927 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60928 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}};
60929 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}};
60930 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60931 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60932 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60933 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60934 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60935 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60936 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60937 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60938 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}};
60939 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60940 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}};
60941 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60942 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60943 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60944 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}};
60945 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60946 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60947 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60948 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60949 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60950 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60951 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60952 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}};
60953 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60954 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60955 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60956 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60957 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60958 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60959 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60960 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60961 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60962 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60963 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60964 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60965 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60966 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60967 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60968 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60969 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60970 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
60971 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60972 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60973 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60974 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60975 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60976 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60977 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60978 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60979 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60980 static swig_cast_info _swigc__p_wxPosition[] = { {&_swigt__p_wxPosition, 0, 0, 0},{0, 0, 0, 0}};
60981 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60982 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60983 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60984 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60985 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60986 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60987 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60988 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60989 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60990 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60991 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60992 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60993 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60994 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60995 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60996 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60997 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60998 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60999 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
61000 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
61001 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
61002 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
61003 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
61004 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}};
61005 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
61006 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}};
61007 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
61008 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
61009 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
61010 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
61011 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
61012 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
61013 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
61014 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
61015 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}};
61016 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
61017 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}};
61018 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
61019 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
61020 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
61021 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
61022
61023 static swig_cast_info *swig_cast_initial[] = {
61024 _swigc__p_buffer,
61025 _swigc__p_char,
61026 _swigc__p_form_ops_t,
61027 _swigc__p_int,
61028 _swigc__p_long,
61029 _swigc__p_unsigned_char,
61030 _swigc__p_unsigned_int,
61031 _swigc__p_unsigned_long,
61032 _swigc__p_wxANIHandler,
61033 _swigc__p_wxAcceleratorEntry,
61034 _swigc__p_wxAcceleratorTable,
61035 _swigc__p_wxActivateEvent,
61036 _swigc__p_wxAppTraits,
61037 _swigc__p_wxArrayString,
61038 _swigc__p_wxBMPHandler,
61039 _swigc__p_wxBitmap,
61040 _swigc__p_wxBoxSizer,
61041 _swigc__p_wxButton,
61042 _swigc__p_wxCURHandler,
61043 _swigc__p_wxCaret,
61044 _swigc__p_wxChildFocusEvent,
61045 _swigc__p_wxClipboardTextEvent,
61046 _swigc__p_wxCloseEvent,
61047 _swigc__p_wxColour,
61048 _swigc__p_wxCommandEvent,
61049 _swigc__p_wxContextMenuEvent,
61050 _swigc__p_wxControl,
61051 _swigc__p_wxControlWithItems,
61052 _swigc__p_wxCursor,
61053 _swigc__p_wxDC,
61054 _swigc__p_wxDateEvent,
61055 _swigc__p_wxDateTime,
61056 _swigc__p_wxDisplayChangedEvent,
61057 _swigc__p_wxDouble,
61058 _swigc__p_wxDropFilesEvent,
61059 _swigc__p_wxDuplexMode,
61060 _swigc__p_wxEraseEvent,
61061 _swigc__p_wxEvent,
61062 _swigc__p_wxEventBlocker,
61063 _swigc__p_wxEventLoop,
61064 _swigc__p_wxEventLoopActivator,
61065 _swigc__p_wxEvtHandler,
61066 _swigc__p_wxFSFile,
61067 _swigc__p_wxFileSystem,
61068 _swigc__p_wxFileSystemHandler,
61069 _swigc__p_wxFlexGridSizer,
61070 _swigc__p_wxFocusEvent,
61071 _swigc__p_wxFont,
61072 _swigc__p_wxFrame,
61073 _swigc__p_wxGBPosition,
61074 _swigc__p_wxGBSizerItem,
61075 _swigc__p_wxGBSpan,
61076 _swigc__p_wxGIFHandler,
61077 _swigc__p_wxGridBagSizer,
61078 _swigc__p_wxGridSizer,
61079 _swigc__p_wxHelpEvent__Origin,
61080 _swigc__p_wxICOHandler,
61081 _swigc__p_wxIconizeEvent,
61082 _swigc__p_wxIdleEvent,
61083 _swigc__p_wxImage,
61084 _swigc__p_wxImageHandler,
61085 _swigc__p_wxImageHistogram,
61086 _swigc__p_wxImage_HSVValue,
61087 _swigc__p_wxImage_RGBValue,
61088 _swigc__p_wxIndividualLayoutConstraint,
61089 _swigc__p_wxInitDialogEvent,
61090 _swigc__p_wxInputStream,
61091 _swigc__p_wxInternetFSHandler,
61092 _swigc__p_wxItemContainer,
61093 _swigc__p_wxJPEGHandler,
61094 _swigc__p_wxKeyEvent,
61095 _swigc__p_wxLayoutConstraints,
61096 _swigc__p_wxMaximizeEvent,
61097 _swigc__p_wxMemoryFSHandler,
61098 _swigc__p_wxMenu,
61099 _swigc__p_wxMenuBar,
61100 _swigc__p_wxMenuBarBase,
61101 _swigc__p_wxMenuEvent,
61102 _swigc__p_wxMenuItem,
61103 _swigc__p_wxMouseCaptureChangedEvent,
61104 _swigc__p_wxMouseCaptureLostEvent,
61105 _swigc__p_wxMouseEvent,
61106 _swigc__p_wxMoveEvent,
61107 _swigc__p_wxNavigationKeyEvent,
61108 _swigc__p_wxNcPaintEvent,
61109 _swigc__p_wxNotifyEvent,
61110 _swigc__p_wxObject,
61111 _swigc__p_wxOutputStream,
61112 _swigc__p_wxPCXHandler,
61113 _swigc__p_wxPNGHandler,
61114 _swigc__p_wxPNMHandler,
61115 _swigc__p_wxPaintEvent,
61116 _swigc__p_wxPaletteChangedEvent,
61117 _swigc__p_wxPaperSize,
61118 _swigc__p_wxPoint,
61119 _swigc__p_wxPoint2D,
61120 _swigc__p_wxPosition,
61121 _swigc__p_wxPropagateOnce,
61122 _swigc__p_wxPropagationDisabler,
61123 _swigc__p_wxPyApp,
61124 _swigc__p_wxPyCommandEvent,
61125 _swigc__p_wxPyDropTarget,
61126 _swigc__p_wxPyEvent,
61127 _swigc__p_wxPyFileSystemHandler,
61128 _swigc__p_wxPyImageHandler,
61129 _swigc__p_wxPyInputStream,
61130 _swigc__p_wxPySizer,
61131 _swigc__p_wxPyValidator,
61132 _swigc__p_wxQuantize,
61133 _swigc__p_wxQueryNewPaletteEvent,
61134 _swigc__p_wxRealPoint,
61135 _swigc__p_wxRect,
61136 _swigc__p_wxRect2D,
61137 _swigc__p_wxRegion,
61138 _swigc__p_wxScrollEvent,
61139 _swigc__p_wxScrollWinEvent,
61140 _swigc__p_wxSetCursorEvent,
61141 _swigc__p_wxShowEvent,
61142 _swigc__p_wxSize,
61143 _swigc__p_wxSizeEvent,
61144 _swigc__p_wxSizer,
61145 _swigc__p_wxSizerFlags,
61146 _swigc__p_wxSizerItem,
61147 _swigc__p_wxStaticBox,
61148 _swigc__p_wxStaticBoxSizer,
61149 _swigc__p_wxStdDialogButtonSizer,
61150 _swigc__p_wxSysColourChangedEvent,
61151 _swigc__p_wxTGAHandler,
61152 _swigc__p_wxTIFFHandler,
61153 _swigc__p_wxToolTip,
61154 _swigc__p_wxUpdateUIEvent,
61155 _swigc__p_wxValidator,
61156 _swigc__p_wxVisualAttributes,
61157 _swigc__p_wxWindow,
61158 _swigc__p_wxWindowCreateEvent,
61159 _swigc__p_wxWindowDestroyEvent,
61160 _swigc__p_wxXPMHandler,
61161 _swigc__p_wxZipFSHandler,
61162 };
61163
61164
61165 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
61166
61167 static swig_const_info swig_const_table[] = {
61168 {0, 0, 0, 0.0, 0, 0}};
61169
61170 #ifdef __cplusplus
61171 }
61172 #endif
61173 /* -----------------------------------------------------------------------------
61174 * Type initialization:
61175 * This problem is tough by the requirement that no dynamic
61176 * memory is used. Also, since swig_type_info structures store pointers to
61177 * swig_cast_info structures and swig_cast_info structures store pointers back
61178 * to swig_type_info structures, we need some lookup code at initialization.
61179 * The idea is that swig generates all the structures that are needed.
61180 * The runtime then collects these partially filled structures.
61181 * The SWIG_InitializeModule function takes these initial arrays out of
61182 * swig_module, and does all the lookup, filling in the swig_module.types
61183 * array with the correct data and linking the correct swig_cast_info
61184 * structures together.
61185 *
61186 * The generated swig_type_info structures are assigned staticly to an initial
61187 * array. We just loop though that array, and handle each type individually.
61188 * First we lookup if this type has been already loaded, and if so, use the
61189 * loaded structure instead of the generated one. Then we have to fill in the
61190 * cast linked list. The cast data is initially stored in something like a
61191 * two-dimensional array. Each row corresponds to a type (there are the same
61192 * number of rows as there are in the swig_type_initial array). Each entry in
61193 * a column is one of the swig_cast_info structures for that type.
61194 * The cast_initial array is actually an array of arrays, because each row has
61195 * a variable number of columns. So to actually build the cast linked list,
61196 * we find the array of casts associated with the type, and loop through it
61197 * adding the casts to the list. The one last trick we need to do is making
61198 * sure the type pointer in the swig_cast_info struct is correct.
61199 *
61200 * First off, we lookup the cast->type name to see if it is already loaded.
61201 * There are three cases to handle:
61202 * 1) If the cast->type has already been loaded AND the type we are adding
61203 * casting info to has not been loaded (it is in this module), THEN we
61204 * replace the cast->type pointer with the type pointer that has already
61205 * been loaded.
61206 * 2) If BOTH types (the one we are adding casting info to, and the
61207 * cast->type) are loaded, THEN the cast info has already been loaded by
61208 * the previous module so we just ignore it.
61209 * 3) Finally, if cast->type has not already been loaded, then we add that
61210 * swig_cast_info to the linked list (because the cast->type) pointer will
61211 * be correct.
61212 * ----------------------------------------------------------------------------- */
61213
61214 #ifdef __cplusplus
61215 extern "C" {
61216 #if 0
61217 } /* c-mode */
61218 #endif
61219 #endif
61220
61221 #if 0
61222 #define SWIGRUNTIME_DEBUG
61223 #endif
61224
61225 SWIGRUNTIME void
61226 SWIG_InitializeModule(void *clientdata) {
61227 size_t i;
61228 swig_module_info *module_head;
61229 static int init_run = 0;
61230
61231 clientdata = clientdata;
61232
61233 if (init_run) return;
61234 init_run = 1;
61235
61236 /* Initialize the swig_module */
61237 swig_module.type_initial = swig_type_initial;
61238 swig_module.cast_initial = swig_cast_initial;
61239
61240 /* Try and load any already created modules */
61241 module_head = SWIG_GetModule(clientdata);
61242 if (module_head) {
61243 swig_module.next = module_head->next;
61244 module_head->next = &swig_module;
61245 } else {
61246 /* This is the first module loaded */
61247 swig_module.next = &swig_module;
61248 SWIG_SetModule(clientdata, &swig_module);
61249 }
61250
61251 /* Now work on filling in swig_module.types */
61252 #ifdef SWIGRUNTIME_DEBUG
61253 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
61254 #endif
61255 for (i = 0; i < swig_module.size; ++i) {
61256 swig_type_info *type = 0;
61257 swig_type_info *ret;
61258 swig_cast_info *cast;
61259
61260 #ifdef SWIGRUNTIME_DEBUG
61261 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61262 #endif
61263
61264 /* if there is another module already loaded */
61265 if (swig_module.next != &swig_module) {
61266 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
61267 }
61268 if (type) {
61269 /* Overwrite clientdata field */
61270 #ifdef SWIGRUNTIME_DEBUG
61271 printf("SWIG_InitializeModule: found type %s\n", type->name);
61272 #endif
61273 if (swig_module.type_initial[i]->clientdata) {
61274 type->clientdata = swig_module.type_initial[i]->clientdata;
61275 #ifdef SWIGRUNTIME_DEBUG
61276 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
61277 #endif
61278 }
61279 } else {
61280 type = swig_module.type_initial[i];
61281 }
61282
61283 /* Insert casting types */
61284 cast = swig_module.cast_initial[i];
61285 while (cast->type) {
61286 /* Don't need to add information already in the list */
61287 ret = 0;
61288 #ifdef SWIGRUNTIME_DEBUG
61289 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
61290 #endif
61291 if (swig_module.next != &swig_module) {
61292 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
61293 #ifdef SWIGRUNTIME_DEBUG
61294 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
61295 #endif
61296 }
61297 if (ret) {
61298 if (type == swig_module.type_initial[i]) {
61299 #ifdef SWIGRUNTIME_DEBUG
61300 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
61301 #endif
61302 cast->type = ret;
61303 ret = 0;
61304 } else {
61305 /* Check for casting already in the list */
61306 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
61307 #ifdef SWIGRUNTIME_DEBUG
61308 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
61309 #endif
61310 if (!ocast) ret = 0;
61311 }
61312 }
61313
61314 if (!ret) {
61315 #ifdef SWIGRUNTIME_DEBUG
61316 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
61317 #endif
61318 if (type->cast) {
61319 type->cast->prev = cast;
61320 cast->next = type->cast;
61321 }
61322 type->cast = cast;
61323 }
61324 cast++;
61325 }
61326 /* Set entry in modules->types array equal to the type */
61327 swig_module.types[i] = type;
61328 }
61329 swig_module.types[i] = 0;
61330
61331 #ifdef SWIGRUNTIME_DEBUG
61332 printf("**** SWIG_InitializeModule: Cast List ******\n");
61333 for (i = 0; i < swig_module.size; ++i) {
61334 int j = 0;
61335 swig_cast_info *cast = swig_module.cast_initial[i];
61336 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61337 while (cast->type) {
61338 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
61339 cast++;
61340 ++j;
61341 }
61342 printf("---- Total casts: %d\n",j);
61343 }
61344 printf("**** SWIG_InitializeModule: Cast List ******\n");
61345 #endif
61346 }
61347
61348 /* This function will propagate the clientdata field of type to
61349 * any new swig_type_info structures that have been added into the list
61350 * of equivalent types. It is like calling
61351 * SWIG_TypeClientData(type, clientdata) a second time.
61352 */
61353 SWIGRUNTIME void
61354 SWIG_PropagateClientData(void) {
61355 size_t i;
61356 swig_cast_info *equiv;
61357 static int init_run = 0;
61358
61359 if (init_run) return;
61360 init_run = 1;
61361
61362 for (i = 0; i < swig_module.size; i++) {
61363 if (swig_module.types[i]->clientdata) {
61364 equiv = swig_module.types[i]->cast;
61365 while (equiv) {
61366 if (!equiv->converter) {
61367 if (equiv->type && !equiv->type->clientdata)
61368 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
61369 }
61370 equiv = equiv->next;
61371 }
61372 }
61373 }
61374 }
61375
61376 #ifdef __cplusplus
61377 #if 0
61378 {
61379 /* c-mode */
61380 #endif
61381 }
61382 #endif
61383
61384
61385
61386 #ifdef __cplusplus
61387 extern "C" {
61388 #endif
61389
61390 /* Python-specific SWIG API */
61391 #define SWIG_newvarlink() SWIG_Python_newvarlink()
61392 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
61393 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
61394
61395 /* -----------------------------------------------------------------------------
61396 * global variable support code.
61397 * ----------------------------------------------------------------------------- */
61398
61399 typedef struct swig_globalvar {
61400 char *name; /* Name of global variable */
61401 PyObject *(*get_attr)(void); /* Return the current value */
61402 int (*set_attr)(PyObject *); /* Set the value */
61403 struct swig_globalvar *next;
61404 } swig_globalvar;
61405
61406 typedef struct swig_varlinkobject {
61407 PyObject_HEAD
61408 swig_globalvar *vars;
61409 } swig_varlinkobject;
61410
61411 SWIGINTERN PyObject *
61412 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
61413 return PyString_FromString("<Swig global variables>");
61414 }
61415
61416 SWIGINTERN PyObject *
61417 swig_varlink_str(swig_varlinkobject *v) {
61418 PyObject *str = PyString_FromString("(");
61419 swig_globalvar *var;
61420 for (var = v->vars; var; var=var->next) {
61421 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
61422 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
61423 }
61424 PyString_ConcatAndDel(&str,PyString_FromString(")"));
61425 return str;
61426 }
61427
61428 SWIGINTERN int
61429 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
61430 PyObject *str = swig_varlink_str(v);
61431 fprintf(fp,"Swig global variables ");
61432 fprintf(fp,"%s\n", PyString_AsString(str));
61433 Py_DECREF(str);
61434 return 0;
61435 }
61436
61437 SWIGINTERN void
61438 swig_varlink_dealloc(swig_varlinkobject *v) {
61439 swig_globalvar *var = v->vars;
61440 while (var) {
61441 swig_globalvar *n = var->next;
61442 free(var->name);
61443 free(var);
61444 var = n;
61445 }
61446 }
61447
61448 SWIGINTERN PyObject *
61449 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
61450 PyObject *res = NULL;
61451 swig_globalvar *var = v->vars;
61452 while (var) {
61453 if (strcmp(var->name,n) == 0) {
61454 res = (*var->get_attr)();
61455 break;
61456 }
61457 var = var->next;
61458 }
61459 if (res == NULL && !PyErr_Occurred()) {
61460 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61461 }
61462 return res;
61463 }
61464
61465 SWIGINTERN int
61466 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
61467 int res = 1;
61468 swig_globalvar *var = v->vars;
61469 while (var) {
61470 if (strcmp(var->name,n) == 0) {
61471 res = (*var->set_attr)(p);
61472 break;
61473 }
61474 var = var->next;
61475 }
61476 if (res == 1 && !PyErr_Occurred()) {
61477 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61478 }
61479 return res;
61480 }
61481
61482 SWIGINTERN PyTypeObject*
61483 swig_varlink_type(void) {
61484 static char varlink__doc__[] = "Swig var link object";
61485 static PyTypeObject varlink_type;
61486 static int type_init = 0;
61487 if (!type_init) {
61488 const PyTypeObject tmp
61489 = {
61490 PyObject_HEAD_INIT(NULL)
61491 0, /* Number of items in variable part (ob_size) */
61492 (char *)"swigvarlink", /* Type name (tp_name) */
61493 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
61494 0, /* Itemsize (tp_itemsize) */
61495 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
61496 (printfunc) swig_varlink_print, /* Print (tp_print) */
61497 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
61498 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
61499 0, /* tp_compare */
61500 (reprfunc) swig_varlink_repr, /* tp_repr */
61501 0, /* tp_as_number */
61502 0, /* tp_as_sequence */
61503 0, /* tp_as_mapping */
61504 0, /* tp_hash */
61505 0, /* tp_call */
61506 (reprfunc)swig_varlink_str, /* tp_str */
61507 0, /* tp_getattro */
61508 0, /* tp_setattro */
61509 0, /* tp_as_buffer */
61510 0, /* tp_flags */
61511 varlink__doc__, /* tp_doc */
61512 0, /* tp_traverse */
61513 0, /* tp_clear */
61514 0, /* tp_richcompare */
61515 0, /* tp_weaklistoffset */
61516 #if PY_VERSION_HEX >= 0x02020000
61517 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
61518 #endif
61519 #if PY_VERSION_HEX >= 0x02030000
61520 0, /* tp_del */
61521 #endif
61522 #ifdef COUNT_ALLOCS
61523 0,0,0,0 /* tp_alloc -> tp_next */
61524 #endif
61525 };
61526 varlink_type = tmp;
61527 varlink_type.ob_type = &PyType_Type;
61528 type_init = 1;
61529 }
61530 return &varlink_type;
61531 }
61532
61533 /* Create a variable linking object for use later */
61534 SWIGINTERN PyObject *
61535 SWIG_Python_newvarlink(void) {
61536 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
61537 if (result) {
61538 result->vars = 0;
61539 }
61540 return ((PyObject*) result);
61541 }
61542
61543 SWIGINTERN void
61544 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
61545 swig_varlinkobject *v = (swig_varlinkobject *) p;
61546 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
61547 if (gv) {
61548 size_t size = strlen(name)+1;
61549 gv->name = (char *)malloc(size);
61550 if (gv->name) {
61551 strncpy(gv->name,name,size);
61552 gv->get_attr = get_attr;
61553 gv->set_attr = set_attr;
61554 gv->next = v->vars;
61555 }
61556 }
61557 v->vars = gv;
61558 }
61559
61560 SWIGINTERN PyObject *
61561 SWIG_globals() {
61562 static PyObject *_SWIG_globals = 0;
61563 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
61564 return _SWIG_globals;
61565 }
61566
61567 /* -----------------------------------------------------------------------------
61568 * constants/methods manipulation
61569 * ----------------------------------------------------------------------------- */
61570
61571 /* Install Constants */
61572 SWIGINTERN void
61573 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
61574 PyObject *obj = 0;
61575 size_t i;
61576 for (i = 0; constants[i].type; ++i) {
61577 switch(constants[i].type) {
61578 case SWIG_PY_POINTER:
61579 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
61580 break;
61581 case SWIG_PY_BINARY:
61582 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
61583 break;
61584 default:
61585 obj = 0;
61586 break;
61587 }
61588 if (obj) {
61589 PyDict_SetItemString(d, constants[i].name, obj);
61590 Py_DECREF(obj);
61591 }
61592 }
61593 }
61594
61595 /* -----------------------------------------------------------------------------*/
61596 /* Fix SwigMethods to carry the callback ptrs when needed */
61597 /* -----------------------------------------------------------------------------*/
61598
61599 SWIGINTERN void
61600 SWIG_Python_FixMethods(PyMethodDef *methods,
61601 swig_const_info *const_table,
61602 swig_type_info **types,
61603 swig_type_info **types_initial) {
61604 size_t i;
61605 for (i = 0; methods[i].ml_name; ++i) {
61606 const char *c = methods[i].ml_doc;
61607 if (c && (c = strstr(c, "swig_ptr: "))) {
61608 int j;
61609 swig_const_info *ci = 0;
61610 const char *name = c + 10;
61611 for (j = 0; const_table[j].type; ++j) {
61612 if (strncmp(const_table[j].name, name,
61613 strlen(const_table[j].name)) == 0) {
61614 ci = &(const_table[j]);
61615 break;
61616 }
61617 }
61618 if (ci) {
61619 size_t shift = (ci->ptype) - types;
61620 swig_type_info *ty = types_initial[shift];
61621 size_t ldoc = (c - methods[i].ml_doc);
61622 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
61623 char *ndoc = (char*)malloc(ldoc + lptr + 10);
61624 if (ndoc) {
61625 char *buff = ndoc;
61626 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
61627 if (ptr) {
61628 strncpy(buff, methods[i].ml_doc, ldoc);
61629 buff += ldoc;
61630 strncpy(buff, "swig_ptr: ", 10);
61631 buff += 10;
61632 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
61633 methods[i].ml_doc = ndoc;
61634 }
61635 }
61636 }
61637 }
61638 }
61639 }
61640
61641 #ifdef __cplusplus
61642 }
61643 #endif
61644
61645 /* -----------------------------------------------------------------------------*
61646 * Partial Init method
61647 * -----------------------------------------------------------------------------*/
61648
61649 #ifdef __cplusplus
61650 extern "C"
61651 #endif
61652 SWIGEXPORT void SWIG_init(void) {
61653 PyObject *m, *d;
61654
61655 /* Fix SwigMethods to carry the callback ptrs when needed */
61656 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
61657
61658 m = Py_InitModule((char *) SWIG_name, SwigMethods);
61659 d = PyModule_GetDict(m);
61660
61661 SWIG_InitializeModule(0);
61662 SWIG_InstallConstants(d,swig_const_table);
61663
61664
61665
61666 #ifndef wxPyUSE_EXPORT
61667 // Make our API structure a CObject so other modules can import it
61668 // from this module.
61669 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
61670 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
61671 Py_XDECREF(cobj);
61672 #endif
61673
61674 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
61675 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
61676 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
61677 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
61678 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
61679 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
61680 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
61681 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
61682 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
61683 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
61684 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
61685 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
61686 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
61687 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
61688 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
61689 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
61690 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
61691 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
61692 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
61693 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
61694 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
61695 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
61696 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
61697 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
61698 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
61699 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
61700 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
61701 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
61702 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
61703 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
61704 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
61705 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
61706 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
61707 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
61708 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
61709 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
61710 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
61711 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
61712 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
61713 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
61714 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
61715 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
61716 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
61717 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
61718 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
61719 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
61720 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
61721 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
61722 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
61723 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
61724 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
61725 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
61726 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
61727 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
61728 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
61729 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
61730 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
61731 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
61732 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
61733 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
61734 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
61735 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
61736 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
61737 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
61738 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
61739 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
61740 SWIG_Python_SetConstant(d, "APPLY",SWIG_From_int(static_cast< int >(wxAPPLY)));
61741 SWIG_Python_SetConstant(d, "CLOSE",SWIG_From_int(static_cast< int >(wxCLOSE)));
61742 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
61743 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
61744 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
61745 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
61746 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61747 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61748 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61749 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61750 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61751 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61752 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61753 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61754 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61755 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61756 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61757 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61758 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61759 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61760 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61761 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61762 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61763 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61764 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61765 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61766 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61767 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61768 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61769 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61770 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61771 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61772 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61773 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61774 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61775 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61776 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61777 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61778 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61779 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61780 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61781 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61782 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61783 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61784 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61785 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61786 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61787 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61788 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61789 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61790 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61791 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61792 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61793 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61794 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61795 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61796 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61797 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61798 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61799 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61800 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61801 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61802 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61803 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61804 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61805 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61806 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61807 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61808 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61809 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61810 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61811 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61812 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61813 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61814 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61815 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61816 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61817 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61818 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61819 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61820 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61821 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61822 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61823 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61824 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61825 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61826 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61827 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61828 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61829 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61830 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61831 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61832 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61833 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61834 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61835 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61836 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61837 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61838 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61839 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61840 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61841 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61842 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61843 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61844 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61845 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61846 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61847 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61848 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61849 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61850 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61851 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61852 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61853 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61854 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61855 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61856 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61857 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61858 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61859 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61860 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61861 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61862 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61863 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61864 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61865 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61866 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61867 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61868 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61869 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61870 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61871 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61872 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61873 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61874 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61875 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61876 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61877 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61878 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61879 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61880 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61881 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61882 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61883 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61884 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61885 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61886 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61887 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61888 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61889 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61890 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61891 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61892 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61893 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61894 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61895 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61896 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61897 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61898 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61899 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61900 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61901 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61902 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61903 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61904 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61905 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61906 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61907 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61908 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61909 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61910 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61911 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61912 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61913 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61914 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61915 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61916 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61917 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61918 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61919 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61920 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61921 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61922 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61923 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61924 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61925 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61926 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61927 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61928 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61929 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61930 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61931 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61932 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61933 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61934 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61935 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61936 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61937 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61938 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61939 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61940 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61941 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61942 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61943 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61944 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61945 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61946 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61947 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61948 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61949 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61950 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61951 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61952 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61953 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61954 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61955 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61956 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61957 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61958 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61959 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61960 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61961 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61962 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61963 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61964 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61965 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61966 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61967 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61968 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61969 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61970 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61971 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61972 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61973 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61974 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61975 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61976 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61977 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61978 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61979 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61980 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61981 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61982 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61983 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61984 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61985 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61986 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61987 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61988 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61989 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61990 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61991 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61992 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61993 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61994 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61995 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61996 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61997 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61998 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61999 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
62000 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
62001 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
62002 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
62003 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
62004 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
62005 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
62006 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
62007 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
62008 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
62009 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
62010 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
62011 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
62012 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
62013 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
62014 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
62015 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
62016 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
62017 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
62018 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
62019 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
62020 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
62021 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
62022 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
62023 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
62024 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
62025 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
62026 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
62027 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
62028 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
62029 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
62030 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
62031 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
62032 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
62033 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
62034 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
62035 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
62036 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
62037 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
62038 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
62039 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
62040 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
62041 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
62042 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
62043 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
62044 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
62045 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
62046 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
62047 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
62048 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
62049 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
62050 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
62051 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
62052 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
62053 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
62054 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
62055 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
62056 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
62057 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
62058 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
62059 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
62060 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
62061 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
62062 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
62063 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
62064 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
62065 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
62066 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
62067 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
62068 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
62069 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
62070 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
62071 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
62072 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
62073 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
62074 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
62075 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
62076 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
62077 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
62078 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
62079 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
62080 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
62081 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
62082 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
62083 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
62084 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
62085 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
62086 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
62087 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
62088 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
62089 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
62090 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
62091 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
62092 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
62093 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
62094 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
62095 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
62096 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
62097 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
62098 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
62099 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
62100 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
62101 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
62102 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
62103 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
62104 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
62105 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
62106 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
62107 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
62108 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
62109 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
62110 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
62111 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
62112 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
62113 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
62114 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
62115 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
62116 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
62117 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
62118 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
62119 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
62120 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
62121 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
62122 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
62123 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
62124 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
62125 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
62126 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
62127 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
62128 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
62129 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
62130 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
62131 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
62132 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
62133 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
62134 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
62135 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
62136 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
62137 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
62138 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
62139 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
62140 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
62141 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
62142 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
62143 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
62144 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
62145 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
62146 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
62147 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
62148 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
62149 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
62150 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
62151 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
62152 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
62153 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
62154 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
62155 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
62156 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
62157 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
62158 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
62159 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
62160 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
62161 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
62162 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
62163 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
62164 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
62165 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
62166 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
62167 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
62168 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
62169 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
62170 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
62171 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
62172 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
62173 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
62174 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
62175 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
62176 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
62177 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
62178 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
62179 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
62180 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
62181 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
62182 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
62183 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
62184 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
62185 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
62186 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
62187 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
62188 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
62189 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
62190 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
62191 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
62192 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
62193 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
62194 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
62195 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
62196 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
62197 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
62198 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
62199 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
62200 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
62201 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
62202 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
62203 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
62204 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
62205 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
62206 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
62207 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
62208 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
62209 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
62210 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
62211 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
62212 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
62213 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
62214 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
62215 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
62216 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
62217 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
62218 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
62219 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
62220 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
62221 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
62222 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
62223 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
62224 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
62225 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
62226 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
62227 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
62228 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
62229 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
62230 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
62231 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
62232 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
62233 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
62234 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
62235 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
62236 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
62237 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
62238 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
62239 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
62240 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
62241 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
62242 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
62243 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
62244 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
62245 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
62246 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
62247 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
62248 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
62249 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
62250 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
62251 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
62252 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
62253 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
62254 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
62255 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
62256 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
62257 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
62258 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
62259 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
62260 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
62261 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
62262 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
62263 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
62264 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
62265 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
62266 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
62267 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
62268 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
62269 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
62270 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
62271 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
62272 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
62273 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
62274 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
62275 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
62276 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
62277 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
62278 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
62279 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
62280 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
62281 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
62282 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
62283 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
62284 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
62285 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
62286 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
62287 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
62288 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
62289 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
62290 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
62291 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
62292 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
62293 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
62294 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
62295 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
62296 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
62297 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
62298 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
62299 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
62300 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
62301 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
62302 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
62303 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
62304 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
62305 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
62306 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
62307 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
62308 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
62309 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
62310 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
62311 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
62312 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
62313 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
62314 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
62315 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
62316 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
62317 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
62318 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
62319 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
62320 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
62321 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
62322 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
62323 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
62324 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
62325 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
62326 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
62327 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
62328 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
62329 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
62330 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
62331
62332 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
62333
62334
62335 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
62336
62337 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
62338 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
62339 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
62340 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
62341 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
62342 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
62343 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
62344 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
62345 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
62346 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
62347 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
62348 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
62349 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
62350 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
62351 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
62352 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_NONE",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_NONE)));
62353 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
62354 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
62355 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
62356 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
62357 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
62358 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
62359 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
62360 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
62361 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
62362 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
62363 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
62364 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
62365 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
62366 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
62367 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
62368 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
62369 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
62370 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
62371 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
62372 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
62373 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
62374 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
62375 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
62376 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
62377 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
62378 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
62379 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
62380 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
62381 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
62382 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
62383 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
62384 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
62385 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
62386 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
62387 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
62388 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
62389 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
62390 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
62391 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
62392 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
62393 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
62394 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
62395 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
62396 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
62397 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
62398 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
62399 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
62400 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
62401 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
62402 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
62403 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
62404 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
62405 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
62406 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
62407 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
62408 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
62409 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
62410 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
62411 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
62412 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
62413 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
62414 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
62415 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
62416 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
62417 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
62418 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
62419 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
62420 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
62421 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
62422 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
62423 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
62424 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
62425 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
62426 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
62427 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
62428 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
62429 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
62430 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
62431 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
62432 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
62433 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
62434 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
62435 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
62436 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
62437 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
62438 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
62439 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
62440 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
62441 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
62442 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
62443 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
62444 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
62445 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
62446 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
62447 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
62448 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
62449 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
62450 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
62451 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
62452 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
62453 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
62454 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
62455 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
62456 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
62457 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
62458 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
62459 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
62460 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
62461 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
62462 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
62463 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
62464 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
62465 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
62466 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
62467 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
62468 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
62469 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
62470 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
62471 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
62472 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
62473 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
62474 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
62475 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
62476 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
62477 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
62478 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
62479 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
62480 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
62481 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
62482 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
62483 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
62484 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
62485 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
62486 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
62487 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
62488 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
62489 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
62490 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
62491 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
62492 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
62493 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
62494 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
62495 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
62496 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
62497 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
62498 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
62499 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
62500 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
62501 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
62502 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
62503 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
62504 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
62505 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
62506 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
62507 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
62508 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
62509 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
62510 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
62511 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
62512 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
62513 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
62514 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
62515 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
62516 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
62517 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
62518 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
62519 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
62520 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
62521 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
62522 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
62523 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
62524 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
62525 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
62526 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
62527 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
62528 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
62529 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
62530 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
62531 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
62532 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
62533 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
62534 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
62535 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
62536 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
62537 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
62538 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
62539 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
62540 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
62541 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
62542 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
62543 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
62544 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
62545 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
62546 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
62547 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
62548 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
62549 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
62550 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
62551 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
62552 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
62553
62554 // Initialize threading, some globals and such
62555 __wxPyPreStart(d);
62556
62557
62558 // Although these are defined in __version__ they need to be here too so
62559 // that an assert can be done to ensure that the wxPython and the wxWindows
62560 // versions match.
62561 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
62562 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
62563 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
62564
62565 }
62566
wxWidgets (Impactor)