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


59ea3913f2316703e8a419b8eda36246ccf279e0
[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_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2546 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxObject swig_types[83]
2550 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2551 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2552 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2555 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2557 #define SWIGTYPE_p_wxPoint swig_types[91]
2558 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2559 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2560 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2561 #define SWIGTYPE_p_wxPyApp swig_types[95]
2562 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2563 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2564 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2566 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2568 #define SWIGTYPE_p_wxPySizer swig_types[102]
2569 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2570 #define SWIGTYPE_p_wxQuantize swig_types[104]
2571 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2572 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2573 #define SWIGTYPE_p_wxRect swig_types[107]
2574 #define SWIGTYPE_p_wxRegion swig_types[108]
2575 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2576 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2577 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2578 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSize swig_types[113]
2580 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSizer swig_types[115]
2582 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2583 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2587 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2588 #define SWIGTYPE_p_wxToolTip swig_types[122]
2589 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2590 #define SWIGTYPE_p_wxValidator swig_types[124]
2591 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2592 #define SWIGTYPE_p_wxWindow swig_types[126]
2593 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2594 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2596 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2597 static swig_type_info *swig_types[132];
2598 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2599 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2600 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2601
2602 /* -------- TYPES TABLE (END) -------- */
2603
2604 #if (PY_VERSION_HEX <= 0x02000000)
2605 # if !defined(SWIG_PYTHON_CLASSIC)
2606 # error "This python version requires to use swig with the '-classic' option"
2607 # endif
2608 #endif
2609 #if (PY_VERSION_HEX <= 0x02020000)
2610 # error "This python version requires to use swig with the '-nomodern' option"
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodernargs' option"
2614 #endif
2615 #ifndef METH_O
2616 # error "This python version requires to use swig with the '-nofastunpack' option"
2617 #endif
2618
2619 /*-----------------------------------------------
2620 @(target):= _core_.so
2621 ------------------------------------------------*/
2622 #define SWIG_init init_core_
2623
2624 #define SWIG_name "_core_"
2625
2626 #define SWIGVERSION 0x010329
2627
2628
2629 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2630 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2631
2632
2633 #include <stdexcept>
2634
2635
2636 namespace swig {
2637 class PyObject_ptr {
2638 protected:
2639 PyObject *_obj;
2640
2641 public:
2642 PyObject_ptr() :_obj(0)
2643 {
2644 }
2645
2646 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2647 {
2648 Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2652 {
2653 if (initial_ref) Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr & operator=(const PyObject_ptr& item)
2657 {
2658 Py_XINCREF(item._obj);
2659 Py_XDECREF(_obj);
2660 _obj = item._obj;
2661 return *this;
2662 }
2663
2664 ~PyObject_ptr()
2665 {
2666 Py_XDECREF(_obj);
2667 }
2668
2669 operator PyObject *() const
2670 {
2671 return _obj;
2672 }
2673
2674 PyObject *operator->() const
2675 {
2676 return _obj;
2677 }
2678 };
2679 }
2680
2681
2682 namespace swig {
2683 struct PyObject_var : PyObject_ptr {
2684 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2685
2686 PyObject_var & operator = (PyObject* obj)
2687 {
2688 Py_XDECREF(_obj);
2689 _obj = obj;
2690 return *this;
2691 }
2692 };
2693 }
2694
2695
2696 #include "wx/wxPython/wxPython_int.h"
2697 #include "wx/wxPython/pyclasses.h"
2698 #include "wx/wxPython/twoitem.h"
2699
2700
2701 #ifndef wxPyUSE_EXPORT
2702 // Helper functions for dealing with SWIG objects and such. These are
2703 // located here so they know about the SWIG types and functions declared
2704 // in the wrapper code.
2705
2706 #include <wx/hashmap.h>
2707 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2708
2709
2710 // Maintains a hashmap of className to swig_type_info pointers. Given the
2711 // name of a class either looks up the type info in the cache, or scans the
2712 // SWIG tables for it.
2713 extern PyObject* wxPyPtrTypeMap;
2714 static
2715 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2716
2717 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2718
2719 if (typeInfoCache == NULL)
2720 typeInfoCache = new wxPyTypeInfoHashMap;
2721
2722 wxString name(className);
2723 swig_type_info* swigType = (*typeInfoCache)[name];
2724
2725 if (! swigType) {
2726 // it wasn't in the cache, so look it up from SWIG
2727 name.Append(wxT(" *"));
2728 swigType = SWIG_TypeQuery(name.mb_str());
2729
2730 // if it still wasn't found, try looking for a mapped name
2731 if (!swigType) {
2732 PyObject* item;
2733 name = className;
2734
2735 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2736 (char*)(const char*)name.mbc_str())) != NULL) {
2737 name = wxString(PyString_AsString(item), *wxConvCurrent);
2738 name.Append(wxT(" *"));
2739 swigType = SWIG_TypeQuery(name.mb_str());
2740 }
2741 }
2742 if (swigType) {
2743 // and add it to the map if found
2744 (*typeInfoCache)[className] = swigType;
2745 }
2746 }
2747 return swigType;
2748 }
2749
2750
2751 // Check if a class name is a type known to SWIG
2752 bool wxPyCheckSwigType(const wxChar* className) {
2753
2754 swig_type_info* swigType = wxPyFindSwigType(className);
2755 return swigType != NULL;
2756 }
2757
2758
2759 // Given a pointer to a C++ object and a class name, construct a Python proxy
2760 // object for it.
2761 PyObject* wxPyConstructObject(void* ptr,
2762 const wxChar* className,
2763 int setThisOwn) {
2764
2765 swig_type_info* swigType = wxPyFindSwigType(className);
2766 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2767
2768 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2769 }
2770
2771
2772 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2773 // Ensures that the proxy object is of the specified (or derived) type. If
2774 // not able to perform the conversion then a Python exception is set and the
2775 // error should be handled properly in the caller. Returns True on success.
2776 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2777 const wxChar* className) {
2778
2779 swig_type_info* swigType = wxPyFindSwigType(className);
2780 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2781
2782 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2783 }
2784
2785
2786
2787 // Make a SWIGified pointer object suitable for a .this attribute
2788 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2789
2790 PyObject* robj = NULL;
2791
2792 swig_type_info* swigType = wxPyFindSwigType(className);
2793 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2794
2795 robj = PySwigObject_New(ptr, swigType, 0);
2796 return robj;
2797 }
2798
2799
2800 // Python's PyInstance_Check does not return True for instances of new-style
2801 // classes. This should get close enough for both new and old classes but I
2802 // should re-evaluate the need for doing instance checks...
2803 bool wxPyInstance_Check(PyObject* obj) {
2804 return PyObject_HasAttrString(obj, "__class__") != 0;
2805 }
2806
2807
2808 // This one checks if the object is an instance of a SWIG proxy class (it has
2809 // a .this attribute, and the .this attribute is a PySwigObject.)
2810 bool wxPySwigInstance_Check(PyObject* obj) {
2811 static PyObject* this_str = NULL;
2812 if (this_str == NULL)
2813 this_str = PyString_FromString("this");
2814
2815 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2816 if (this_attr) {
2817 bool retval = (PySwigObject_Check(this_attr) != 0);
2818 Py_DECREF(this_attr);
2819 return retval;
2820 }
2821
2822 PyErr_Clear();
2823 return false;
2824 }
2825
2826
2827 // Export a C API in a struct. Other modules will be able to load this from
2828 // the wx._core_ module and will then have safe access to these functions,
2829 // even if they are located in another shared library.
2830 static wxPyCoreAPI API = {
2831
2832 wxPyCheckSwigType,
2833 wxPyConstructObject,
2834 wxPyConvertSwigPtr,
2835 wxPyMakeSwigPtr,
2836
2837 wxPyBeginAllowThreads,
2838 wxPyEndAllowThreads,
2839 wxPyBeginBlockThreads,
2840 wxPyEndBlockThreads,
2841
2842 wxPy_ConvertList,
2843
2844 wxString_in_helper,
2845 Py2wxString,
2846 wx2PyString,
2847
2848 byte_LIST_helper,
2849 int_LIST_helper,
2850 long_LIST_helper,
2851 string_LIST_helper,
2852 wxPoint_LIST_helper,
2853 wxBitmap_LIST_helper,
2854 wxString_LIST_helper,
2855 wxAcceleratorEntry_LIST_helper,
2856
2857 wxSize_helper,
2858 wxPoint_helper,
2859 wxRealPoint_helper,
2860 wxRect_helper,
2861 wxColour_helper,
2862 wxPoint2D_helper,
2863
2864 wxPySimple_typecheck,
2865 wxColour_typecheck,
2866
2867 wxPyCBH_setCallbackInfo,
2868 wxPyCBH_findCallback,
2869 wxPyCBH_callCallback,
2870 wxPyCBH_callCallbackObj,
2871 wxPyCBH_delete,
2872
2873 wxPyMake_wxObject,
2874 wxPyMake_wxSizer,
2875 wxPyPtrTypeMap_Add,
2876 wxPy2int_seq_helper,
2877 wxPy4int_seq_helper,
2878 wxArrayString2PyList_helper,
2879 wxArrayInt2PyList_helper,
2880
2881 wxPyClientData_dtor,
2882 wxPyUserData_dtor,
2883 wxPyOORClientData_dtor,
2884
2885 wxPyCBInputStream_create,
2886 wxPyCBInputStream_copy,
2887
2888 wxPyInstance_Check,
2889 wxPySwigInstance_Check,
2890
2891 wxPyCheckForApp
2892
2893 };
2894
2895 #endif
2896
2897
2898 #if !WXWIN_COMPATIBILITY_2_4
2899 #define wxHIDE_READONLY 0
2900 #endif
2901
2902
2903 #define SWIG_From_long PyInt_FromLong
2904
2905
2906 SWIGINTERNINLINE PyObject *
2907 SWIG_From_int (int value)
2908 {
2909 return SWIG_From_long (value);
2910 }
2911
2912 static const wxString wxPyEmptyString(wxEmptyString);
2913 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2914 return self->GetClassInfo()->GetClassName();
2915 }
2916 SWIGINTERN void wxObject_Destroy(wxObject *self){
2917 delete self;
2918 }
2919
2920 #ifndef __WXMAC__
2921 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2922 #endif
2923
2924
2925 #include <limits.h>
2926 #ifndef LLONG_MIN
2927 # define LLONG_MIN LONG_LONG_MIN
2928 #endif
2929 #ifndef LLONG_MAX
2930 # define LLONG_MAX LONG_LONG_MAX
2931 #endif
2932 #ifndef ULLONG_MAX
2933 # define ULLONG_MAX ULONG_LONG_MAX
2934 #endif
2935
2936
2937 SWIGINTERN int
2938 SWIG_AsVal_long (PyObject* obj, long* val)
2939 {
2940 if (PyNumber_Check(obj)) {
2941 if (val) *val = PyInt_AsLong(obj);
2942 return SWIG_OK;
2943 }
2944 return SWIG_TypeError;
2945 }
2946
2947
2948 SWIGINTERN int
2949 SWIG_AsVal_int (PyObject * obj, int *val)
2950 {
2951 long v;
2952 int res = SWIG_AsVal_long (obj, &v);
2953 if (SWIG_IsOK(res)) {
2954 if ((v < INT_MIN || v > INT_MAX)) {
2955 return SWIG_OverflowError;
2956 } else {
2957 if (val) *val = static_cast< int >(v);
2958 }
2959 }
2960 return res;
2961 }
2962
2963 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2964 wxSize temp, *obj = &temp;
2965 if ( other == Py_None ) return false;
2966 if ( ! wxSize_helper(other, &obj) ) {
2967 PyErr_Clear();
2968 return false;
2969 }
2970 return self->operator==(*obj);
2971 }
2972 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return true;
2975 if ( ! wxSize_helper(other, &obj)) {
2976 PyErr_Clear();
2977 return true;
2978 }
2979 return self->operator!=(*obj);
2980 }
2981 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2983 PyObject* tup = PyTuple_New(2);
2984 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2985 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2986 wxPyEndBlockThreads(blocked);
2987 return tup;
2988 }
2989
2990 SWIGINTERN int
2991 SWIG_AsVal_double (PyObject *obj, double* val)
2992 {
2993 if (PyNumber_Check(obj)) {
2994 if (val) *val = PyFloat_AsDouble(obj);
2995 return SWIG_OK;
2996 }
2997 return SWIG_TypeError;
2998 }
2999
3000
3001 #define SWIG_From_double PyFloat_FromDouble
3002
3003 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3004 wxRealPoint temp, *obj = &temp;
3005 if ( other == Py_None ) return false;
3006 if ( ! wxRealPoint_helper(other, &obj) ) {
3007 PyErr_Clear();
3008 return false;
3009 }
3010 return self->operator==(*obj);
3011 }
3012 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3013 wxRealPoint temp, *obj = &temp;
3014 if ( other == Py_None ) return true;
3015 if ( ! wxRealPoint_helper(other, &obj)) {
3016 PyErr_Clear();
3017 return true;
3018 }
3019 return self->operator!=(*obj);
3020 }
3021 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3022 self->x = x;
3023 self->y = y;
3024 }
3025 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3027 PyObject* tup = PyTuple_New(2);
3028 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3029 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3030 wxPyEndBlockThreads(blocked);
3031 return tup;
3032 }
3033 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3034 wxPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return false;
3036 if ( ! wxPoint_helper(other, &obj) ) {
3037 PyErr_Clear();
3038 return false;
3039 }
3040 return self->operator==(*obj);
3041 }
3042 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3043 wxPoint temp, *obj = &temp;
3044 if ( other == Py_None ) return true;
3045 if ( ! wxPoint_helper(other, &obj)) {
3046 PyErr_Clear();
3047 return true;
3048 }
3049 return self->operator!=(*obj);
3050 }
3051 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3052 self->x = x;
3053 self->y = y;
3054 }
3055 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3057 PyObject* tup = PyTuple_New(2);
3058 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3059 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3060 wxPyEndBlockThreads(blocked);
3061 return tup;
3062 }
3063 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3064 wxRect temp, *obj = &temp;
3065 if ( other == Py_None ) return false;
3066 if ( ! wxRect_helper(other, &obj) ) {
3067 PyErr_Clear();
3068 return false;
3069 }
3070 return self->operator==(*obj);
3071 }
3072 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3073 wxRect temp, *obj = &temp;
3074 if ( other == Py_None ) return true;
3075 if ( ! wxRect_helper(other, &obj)) {
3076 PyErr_Clear();
3077 return true;
3078 }
3079 return self->operator!=(*obj);
3080 }
3081 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3082 self->x = x;
3083 self->y = y;
3084 self->width = width;
3085 self->height = height;
3086 }
3087 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3089 PyObject* tup = PyTuple_New(4);
3090 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3091 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3092 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3093 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3094 wxPyEndBlockThreads(blocked);
3095 return tup;
3096 }
3097
3098 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3099 wxRegion reg1(*r1);
3100 wxRegion reg2(*r2);
3101 wxRect dest(0,0,0,0);
3102 PyObject* obj;
3103
3104 reg1.Intersect(reg2);
3105 dest = reg1.GetBox();
3106
3107 if (dest != wxRect(0,0,0,0)) {
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 wxRect* newRect = new wxRect(dest);
3110 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3111 wxPyEndBlockThreads(blocked);
3112 return obj;
3113 }
3114 Py_INCREF(Py_None);
3115 return Py_None;
3116 }
3117
3118 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3119 wxPoint2D temp, *obj = &temp;
3120 if ( other == Py_None ) return false;
3121 if ( ! wxPoint2D_helper(other, &obj) ) {
3122 PyErr_Clear();
3123 return false;
3124 }
3125 return self->operator==(*obj);
3126 }
3127 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3128 wxPoint2D temp, *obj = &temp;
3129 if ( other == Py_None ) return true;
3130 if ( ! wxPoint2D_helper(other, &obj)) {
3131 PyErr_Clear();
3132 return true;
3133 }
3134 return self->operator!=(*obj);
3135 }
3136 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3137 self->m_x = x;
3138 self->m_y = y;
3139 }
3140 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 PyObject* tup = PyTuple_New(2);
3143 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3144 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3145 wxPyEndBlockThreads(blocked);
3146 return tup;
3147 }
3148
3149 #include "wx/wxPython/pyistream.h"
3150
3151 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3152 wxInputStream* wxis = wxPyCBInputStream::create(p);
3153 if (wxis)
3154 return new wxPyInputStream(wxis);
3155 else
3156 return NULL;
3157 }
3158
3159 SWIGINTERN swig_type_info*
3160 SWIG_pchar_descriptor()
3161 {
3162 static int init = 0;
3163 static swig_type_info* info = 0;
3164 if (!init) {
3165 info = SWIG_TypeQuery("_p_char");
3166 init = 1;
3167 }
3168 return info;
3169 }
3170
3171
3172 SWIGINTERNINLINE PyObject *
3173 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3174 {
3175 if (carray) {
3176 if (size > INT_MAX) {
3177 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3178 return pchar_descriptor ?
3179 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3180 } else {
3181 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3182 }
3183 } else {
3184 return SWIG_Py_Void();
3185 }
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject *
3190 SWIG_From_char (char c)
3191 {
3192 return SWIG_FromCharPtrAndSize(&c,1);
3193 }
3194
3195
3196 SWIGINTERNINLINE PyObject*
3197 SWIG_From_unsigned_SS_long (unsigned long value)
3198 {
3199 return (value > LONG_MAX) ?
3200 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3201 }
3202
3203
3204 SWIGINTERNINLINE PyObject *
3205 SWIG_From_size_t (size_t value)
3206 {
3207 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3208 }
3209
3210
3211 SWIGINTERN int
3212 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3213 {
3214 if (PyString_Check(obj)) {
3215 char *cstr; Py_ssize_t len;
3216 PyString_AsStringAndSize(obj, &cstr, &len);
3217 if (cptr) {
3218 if (alloc) {
3219 /*
3220 In python the user should not be able to modify the inner
3221 string representation. To warranty that, if you define
3222 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3223 buffer is always returned.
3224
3225 The default behavior is just to return the pointer value,
3226 so, be careful.
3227 */
3228 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3229 if (*alloc != SWIG_OLDOBJ)
3230 #else
3231 if (*alloc == SWIG_NEWOBJ)
3232 #endif
3233 {
3234 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3235 *alloc = SWIG_NEWOBJ;
3236 }
3237 else {
3238 *cptr = cstr;
3239 *alloc = SWIG_OLDOBJ;
3240 }
3241 } else {
3242 *cptr = PyString_AsString(obj);
3243 }
3244 }
3245 if (psize) *psize = len + 1;
3246 return SWIG_OK;
3247 } else {
3248 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3249 if (pchar_descriptor) {
3250 void* vptr = 0;
3251 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3252 if (cptr) *cptr = (char *) vptr;
3253 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3254 if (alloc) *alloc = SWIG_OLDOBJ;
3255 return SWIG_OK;
3256 }
3257 }
3258 }
3259 return SWIG_TypeError;
3260 }
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3265 {
3266 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3267 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3268 if (SWIG_IsOK(res)) {
3269 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3270 if (csize <= size) {
3271 if (val) {
3272 if (csize) memcpy(val, cptr, csize*sizeof(char));
3273 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3274 }
3275 if (alloc == SWIG_NEWOBJ) {
3276 delete[] cptr;
3277 res = SWIG_DelNewMask(res);
3278 }
3279 return res;
3280 }
3281 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3282 }
3283 return SWIG_TypeError;
3284 }
3285
3286
3287 SWIGINTERN int
3288 SWIG_AsVal_char (PyObject * obj, char *val)
3289 {
3290 int res = SWIG_AsCharArray(obj, val, 1);
3291 if (!SWIG_IsOK(res)) {
3292 long v;
3293 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3294 if (SWIG_IsOK(res)) {
3295 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3296 if (val) *val = static_cast< char >(v);
3297 } else {
3298 res = SWIG_OverflowError;
3299 }
3300 }
3301 }
3302 return res;
3303 }
3304
3305 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3306 // We use only strings for the streams, not unicode
3307 PyObject* str = PyObject_Str(obj);
3308 if (! str) {
3309 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3310 return;
3311 }
3312 self->Write(PyString_AS_STRING(str),
3313 PyString_GET_SIZE(str));
3314 Py_DECREF(str);
3315 }
3316
3317 #include "wx/wxPython/pyistream.h"
3318
3319
3320 class wxPyFileSystemHandler : public wxFileSystemHandler
3321 {
3322 public:
3323 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3324
3325 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3326 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3327 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3328 DEC_PYCALLBACK_STRING__pure(FindNext);
3329
3330 wxString GetProtocol(const wxString& location) {
3331 return wxFileSystemHandler::GetProtocol(location);
3332 }
3333
3334 wxString GetLeftLocation(const wxString& location) {
3335 return wxFileSystemHandler::GetLeftLocation(location);
3336 }
3337
3338 wxString GetAnchor(const wxString& location) {
3339 return wxFileSystemHandler::GetAnchor(location);
3340 }
3341
3342 wxString GetRightLocation(const wxString& location) {
3343 return wxFileSystemHandler::GetRightLocation(location);
3344 }
3345
3346 wxString GetMimeTypeFromExt(const wxString& location) {
3347 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3348 }
3349
3350 PYPRIVATE;
3351 };
3352
3353
3354 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3355 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3356 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3357 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3358
3359
3360 SWIGINTERN int
3361 SWIG_AsVal_bool (PyObject *obj, bool *val)
3362 {
3363 if (obj == Py_True) {
3364 if (val) *val = true;
3365 return SWIG_OK;
3366 } else if (obj == Py_False) {
3367 if (val) *val = false;
3368 return SWIG_OK;
3369 } else {
3370 long v = 0;
3371 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3372 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3373 return res;
3374 }
3375 }
3376
3377 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3378 wxFileName fname = wxFileSystem::URLToFileName(url);
3379 return fname.GetFullPath();
3380 }
3381
3382 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3383 wxImage& image,
3384 long type) {
3385 wxMemoryFSHandler::AddFile(filename, image, type);
3386 }
3387
3388 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3389 const wxBitmap& bitmap,
3390 long type) {
3391 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3392 }
3393
3394 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3395 PyObject* data) {
3396 if (! PyString_Check(data)) {
3397 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3398 "Expected string object"));
3399 return;
3400 }
3401
3402 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3403 void* ptr = (void*)PyString_AsString(data);
3404 size_t size = PyString_Size(data);
3405 wxPyEndBlockThreads(blocked);
3406
3407 wxMemoryFSHandler::AddFile(filename, ptr, size);
3408 }
3409
3410
3411 #include "wx/wxPython/pyistream.h"
3412
3413
3414 SWIGINTERN int
3415 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3416 {
3417 long v = 0;
3418 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3419 return SWIG_TypeError;
3420 }
3421 else if (val)
3422 *val = (unsigned long)v;
3423 return SWIG_OK;
3424 }
3425
3426
3427 SWIGINTERN int
3428 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3429 {
3430 unsigned long v;
3431 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3432 if (SWIG_IsOK(res)) {
3433 if ((v > UCHAR_MAX)) {
3434 return SWIG_OverflowError;
3435 } else {
3436 if (val) *val = static_cast< unsigned char >(v);
3437 }
3438 }
3439 return res;
3440 }
3441
3442
3443 SWIGINTERNINLINE PyObject *
3444 SWIG_From_unsigned_SS_char (unsigned char value)
3445 {
3446 return SWIG_From_unsigned_SS_long (value);
3447 }
3448
3449 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3454 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3459 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3460 colour.Green(),
3461 colour.Blue());
3462 wxImageHistogramEntry e = (*self)[key];
3463 return e.value;
3464 }
3465
3466 typedef unsigned char* buffer;
3467
3468
3469 // Pull the nested class out to the top level for SWIG's sake
3470 #define wxImage_RGBValue wxImage::RGBValue
3471 #define wxImage_HSVValue wxImage::HSVValue
3472
3473 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3474 if (width > 0 && height > 0)
3475 return new wxImage(width, height, clear);
3476 else
3477 return new wxImage;
3478 }
3479 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3480 return new wxImage(bitmap.ConvertToImage());
3481 }
3482 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3483 if (DATASIZE != width*height*3) {
3484 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3485 return NULL;
3486 }
3487
3488 // Copy the source data so the wxImage can clean it up later
3489 buffer copy = (buffer)malloc(DATASIZE);
3490 if (copy == NULL) {
3491 wxPyBLOCK_THREADS(PyErr_NoMemory());
3492 return NULL;
3493 }
3494 memcpy(copy, data, DATASIZE);
3495 return new wxImage(width, height, copy, false);
3496 }
3497 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3498 if (DATASIZE != width*height*3) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3500 return NULL;
3501 }
3502 if (ALPHASIZE != width*height) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer dcopy = (buffer)malloc(DATASIZE);
3509 if (dcopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(dcopy, data, DATASIZE);
3514
3515 buffer acopy = (buffer)malloc(ALPHASIZE);
3516 if (acopy == NULL) {
3517 wxPyBLOCK_THREADS(PyErr_NoMemory());
3518 return NULL;
3519 }
3520 memcpy(acopy, alpha, ALPHASIZE);
3521
3522 return new wxImage(width, height, dcopy, acopy, false);
3523 }
3524 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3525 wxSize size(self->GetWidth(), self->GetHeight());
3526 return size;
3527 }
3528 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3529 buffer data = self->GetData();
3530 int len = self->GetWidth() * self->GetHeight() * 3;
3531 PyObject* rv;
3532 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3533 return rv;
3534 }
3535 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3536 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3537 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3538 return;
3539 }
3540 buffer copy = (buffer)malloc(DATASIZE);
3541 if (copy == NULL) {
3542 wxPyBLOCK_THREADS(PyErr_NoMemory());
3543 return;
3544 }
3545 memcpy(copy, data, DATASIZE);
3546 self->SetData(copy, false);
3547 // wxImage takes ownership of copy...
3548 }
3549 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3550 buffer data = self->GetData();
3551 int len = self->GetWidth() * self->GetHeight() * 3;
3552 PyObject* rv;
3553 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3554 return rv;
3555 }
3556 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3557 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3558 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3559 return;
3560 }
3561 self->SetData(data, true);
3562 }
3563 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3564 buffer data = self->GetAlpha();
3565 if (! data) {
3566 RETURN_NONE();
3567 } else {
3568 int len = self->GetWidth() * self->GetHeight();
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3571 return rv;
3572 }
3573 }
3574 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3575 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3577 return;
3578 }
3579 buffer acopy = (buffer)malloc(ALPHASIZE);
3580 if (acopy == NULL) {
3581 wxPyBLOCK_THREADS(PyErr_NoMemory());
3582 return;
3583 }
3584 memcpy(acopy, alpha, ALPHASIZE);
3585 self->SetAlpha(acopy, false);
3586 // wxImage takes ownership of acopy...
3587 }
3588 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3589 buffer data = self->GetAlpha();
3590 int len = self->GetWidth() * self->GetHeight();
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3596 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3598 return;
3599 }
3600 self->SetAlpha(alpha, true);
3601 }
3602 SWIGINTERN PyObject *wxImage_GetHandlers(){
3603 wxList& list = wxImage::GetHandlers();
3604 return wxPy_ConvertList(&list);
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3607 wxBitmap bitmap(*self, depth);
3608 return bitmap;
3609 }
3610 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3611 wxImage mono = self->ConvertToMono( red, green, blue );
3612 wxBitmap bitmap( mono, 1 );
3613 return bitmap;
3614 }
3615 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3616 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3617 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3618 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3619 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3620 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3621 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3622 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3623 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3624 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3625 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3626 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3627 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3628 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3629 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3630
3631 #include <wx/quantize.h>
3632
3633 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3634 return wxQuantize::Quantize(src, dest,
3635 //NULL, // palette
3636 desiredNoColours,
3637 NULL, // eightBitData
3638 flags);
3639 }
3640 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3641 if (PyCallable_Check(func)) {
3642 self->Connect(id, lastId, eventType,
3643 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3644 new wxPyCallback(func));
3645 }
3646 else if (func == Py_None) {
3647 self->Disconnect(id, lastId, eventType,
3648 (wxObjectEventFunction)
3649 &wxPyCallback::EventThunker);
3650 }
3651 else {
3652 wxPyBLOCK_THREADS(
3653 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3654 }
3655 }
3656 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3657 return self->Disconnect(id, lastId, eventType,
3658 (wxObjectEventFunction)
3659 &wxPyCallback::EventThunker);
3660 }
3661 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3662 if (_self && _self != Py_None) {
3663 self->SetClientObject(new wxPyOORClientData(_self, incref));
3664 }
3665 else {
3666 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3667 if (data) {
3668 self->SetClientObject(NULL); // This will delete it too
3669 }
3670 }
3671 }
3672
3673 #if ! wxUSE_HOTKEY
3674 #define wxEVT_HOTKEY -9999
3675 #endif
3676
3677 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3678 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3679 if (data) {
3680 Py_INCREF(data->m_obj);
3681 return data->m_obj;
3682 } else {
3683 Py_INCREF(Py_None);
3684 return Py_None;
3685 }
3686 }
3687 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3688 wxPyClientData* data = new wxPyClientData(clientData);
3689 self->SetClientObject(data);
3690 }
3691 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3692 #if wxUSE_UNICODE
3693 return self->GetUnicodeKey();
3694 #else
3695 return 0;
3696 #endif
3697 }
3698 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3699 #if wxUSE_UNICODE
3700 self->m_uniChar = uniChar;
3701 #endif
3702 }
3703
3704 SWIGINTERNINLINE PyObject *
3705 SWIG_From_unsigned_SS_int (unsigned int value)
3706 {
3707 return SWIG_From_unsigned_SS_long (value);
3708 }
3709
3710
3711 SWIGINTERN int
3712 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3713 {
3714 unsigned long v;
3715 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3716 if (SWIG_IsOK(res)) {
3717 if ((v > UINT_MAX)) {
3718 return SWIG_OverflowError;
3719 } else {
3720 if (val) *val = static_cast< unsigned int >(v);
3721 }
3722 }
3723 return res;
3724 }
3725
3726 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3727 self->m_size = size;
3728 }
3729 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3730 int count = self->GetNumberOfFiles();
3731 wxString* files = self->GetFiles();
3732 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3733 PyObject* list = PyList_New(count);
3734
3735 if (!list) {
3736 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3737 wxPyEndBlockThreads(blocked);
3738 return NULL;
3739 }
3740
3741 for (int i=0; i<count; i++) {
3742 PyList_SetItem(list, i, wx2PyString(files[i]));
3743 }
3744 wxPyEndBlockThreads(blocked);
3745 return list;
3746 }
3747
3748
3749 SWIGINTERN wxPyApp *new_wxPyApp(){
3750 wxPythonApp = new wxPyApp();
3751 return wxPythonApp;
3752 }
3753
3754 void wxApp_CleanUp() {
3755 __wxPyCleanup();
3756 }
3757
3758
3759 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3760
3761
3762
3763
3764
3765 SWIGINTERNINLINE PyObject *
3766 SWIG_FromCharPtr(const char *cptr)
3767 {
3768 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3769 }
3770
3771
3772 #if 0 // #ifdef __WXMAC__
3773
3774 // A dummy class that raises an exception if used...
3775 class wxEventLoop
3776 {
3777 public:
3778 wxEventLoop() { wxPyRaiseNotImplemented(); }
3779 int Run() { return 0; }
3780 void Exit(int rc = 0) {}
3781 bool Pending() const { return false; }
3782 bool Dispatch() { return false; }
3783 bool IsRunning() const { return false; }
3784 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3785 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3786 };
3787
3788 #else
3789
3790 #include <wx/evtloop.h>
3791
3792 #endif
3793
3794
3795
3796 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3797 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3798 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3799 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3800 wxWindowList& list = self->GetChildren();
3801 return wxPy_ConvertList(&list);
3802 }
3803 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3804 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3805 #if wxUSE_HOTKEY
3806 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3807 #else
3808 return false;
3809 #endif
3810 }
3811 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3812
3813
3814
3815 return false;
3816
3817 }
3818 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3819 return wxPyGetWinHandle(self);
3820 }
3821 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3822 self->AssociateHandle((WXWidget)handle);
3823 }
3824
3825 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3826 return wxWindow::FindWindowById(id, parent);
3827 }
3828
3829 wxWindow* wxFindWindowByName( const wxString& name,
3830 const wxWindow *parent = NULL ) {
3831 return wxWindow::FindWindowByName(name, parent);
3832 }
3833
3834 wxWindow* wxFindWindowByLabel( const wxString& label,
3835 const wxWindow *parent = NULL ) {
3836 return wxWindow::FindWindowByLabel(label, parent);
3837 }
3838
3839
3840 #ifdef __WXMSW__
3841 #include <wx/msw/private.h> // to get wxGetWindowId
3842 #endif
3843
3844
3845 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3846 #ifdef __WXMSW__
3847 WXHWND hWnd = (WXHWND)_hWnd;
3848 long id = wxGetWindowId(hWnd);
3849 wxWindow* win = new wxWindow;
3850 if (parent)
3851 parent->AddChild(win);
3852 win->SetEventHandler(win);
3853 win->SetHWND(hWnd);
3854 win->SetId(id);
3855 win->SubclassWin(hWnd);
3856 win->AdoptAttributesFromHWND();
3857 win->SetupColours();
3858 return win;
3859 #else
3860 wxPyRaiseNotImplemented();
3861 return NULL;
3862 #endif
3863 }
3864
3865
3866 PyObject* GetTopLevelWindows() {
3867 return wxPy_ConvertList(&wxTopLevelWindows);
3868 }
3869
3870
3871 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3872 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3873 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3874
3875 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3876
3877
3878 SWIGINTERNINLINE int
3879 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3880 {
3881 unsigned long v;
3882 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3883 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3884 return res;
3885 }
3886
3887 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3888 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3889 wxMenuItemList& list = self->GetMenuItems();
3890 return wxPy_ConvertList(&list);
3891 }
3892 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3893 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3894 static const wxString wxPyControlNameStr(wxControlNameStr);
3895 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3896 if (clientData) {
3897 wxPyClientData* data = new wxPyClientData(clientData);
3898 return self->Append(item, data);
3899 } else
3900 return self->Append(item);
3901 }
3902 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3903 if (clientData) {
3904 wxPyClientData* data = new wxPyClientData(clientData);
3905 return self->Insert(item, pos, data);
3906 } else
3907 return self->Insert(item, pos);
3908 }
3909 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3910 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3911 if (data) {
3912 Py_INCREF(data->m_obj);
3913 return data->m_obj;
3914 } else {
3915 Py_INCREF(Py_None);
3916 return Py_None;
3917 }
3918 }
3919 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3920 wxPyClientData* data = new wxPyClientData(clientData);
3921 self->SetClientObject(n, data);
3922 }
3923
3924
3925 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3926 wxPyUserData* data = NULL;
3927 if ( userData ) {
3928 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3929 data = new wxPyUserData(userData);
3930 wxPyEndBlockThreads(blocked);
3931 }
3932 return new wxSizerItem(window, proportion, flag, border, data);
3933 }
3934 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3935 wxPyUserData* data = NULL;
3936 if ( userData ) {
3937 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3938 data = new wxPyUserData(userData);
3939 wxPyEndBlockThreads(blocked);
3940 }
3941 return new wxSizerItem(width, height, proportion, flag, border, data);
3942 }
3943 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3944 wxPyUserData* data = NULL;
3945 if ( userData ) {
3946 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3947 data = new wxPyUserData(userData);
3948 wxPyEndBlockThreads(blocked);
3949 }
3950 return new wxSizerItem(sizer, proportion, flag, border, data);
3951 }
3952
3953 #include <float.h>
3954
3955
3956 SWIGINTERN int
3957 SWIG_AsVal_float (PyObject * obj, float *val)
3958 {
3959 double v;
3960 int res = SWIG_AsVal_double (obj, &v);
3961 if (SWIG_IsOK(res)) {
3962 if ((v < -FLT_MAX || v > FLT_MAX)) {
3963 return SWIG_OverflowError;
3964 } else {
3965 if (val) *val = static_cast< float >(v);
3966 }
3967 }
3968 return res;
3969 }
3970
3971
3972 SWIGINTERNINLINE PyObject *
3973 SWIG_From_float (float value)
3974 {
3975 return SWIG_From_double (value);
3976 }
3977
3978 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3979 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3980 if (data) {
3981 Py_INCREF(data->m_obj);
3982 return data->m_obj;
3983 } else {
3984 Py_INCREF(Py_None);
3985 return Py_None;
3986 }
3987 }
3988 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3989 wxPyUserData* data = NULL;
3990 if ( userData ) {
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 data = new wxPyUserData(userData);
3993 wxPyEndBlockThreads(blocked);
3994 }
3995 self->SetUserData(data);
3996 }
3997
3998 // Figure out the type of the sizer item
3999
4000 struct wxPySizerItemInfo {
4001 wxPySizerItemInfo()
4002 : window(NULL), sizer(NULL), gotSize(false),
4003 size(wxDefaultSize), gotPos(false), pos(-1)
4004 {}
4005
4006 wxWindow* window;
4007 wxSizer* sizer;
4008 bool gotSize;
4009 wxSize size;
4010 bool gotPos;
4011 int pos;
4012 };
4013
4014 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4015
4016 wxPySizerItemInfo info;
4017 wxSize size;
4018 wxSize* sizePtr = &size;
4019
4020 // Find out what the type of the item is
4021 // try wxWindow
4022 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4023 PyErr_Clear();
4024 info.window = NULL;
4025
4026 // try wxSizer
4027 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4028 PyErr_Clear();
4029 info.sizer = NULL;
4030
4031 // try wxSize or (w,h)
4032 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4033 info.size = *sizePtr;
4034 info.gotSize = true;
4035 }
4036
4037 // or a single int
4038 if (checkIdx && PyInt_Check(item)) {
4039 info.pos = PyInt_AsLong(item);
4040 info.gotPos = true;
4041 }
4042 }
4043 }
4044
4045 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4046 // no expected type, figure out what kind of error message to generate
4047 if ( !checkSize && !checkIdx )
4048 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4049 else if ( checkSize && !checkIdx )
4050 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4051 else if ( !checkSize && checkIdx)
4052 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4053 else
4054 // can this one happen?
4055 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4056 }
4057
4058 return info;
4059 }
4060
4061 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4062 if (!self->GetClientObject())
4063 self->SetClientObject(new wxPyOORClientData(_self));
4064 }
4065 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4066
4067 wxPyUserData* data = NULL;
4068 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4069 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4070 if ( userData && (info.window || info.sizer || info.gotSize) )
4071 data = new wxPyUserData(userData);
4072 if ( info.sizer )
4073 PyObject_SetAttrString(item,"thisown",Py_False);
4074 wxPyEndBlockThreads(blocked);
4075
4076 // Now call the real Add method if a valid item type was found
4077 if ( info.window )
4078 return self->Add(info.window, proportion, flag, border, data);
4079 else if ( info.sizer )
4080 return self->Add(info.sizer, proportion, flag, border, data);
4081 else if (info.gotSize)
4082 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4083 proportion, flag, border, data);
4084 else
4085 return NULL;
4086 }
4087 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4088
4089 wxPyUserData* data = NULL;
4090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4092 if ( userData && (info.window || info.sizer || info.gotSize) )
4093 data = new wxPyUserData(userData);
4094 if ( info.sizer )
4095 PyObject_SetAttrString(item,"thisown",Py_False);
4096 wxPyEndBlockThreads(blocked);
4097
4098 // Now call the real Insert method if a valid item type was found
4099 if ( info.window )
4100 return self->Insert(before, info.window, proportion, flag, border, data);
4101 else if ( info.sizer )
4102 return self->Insert(before, info.sizer, proportion, flag, border, data);
4103 else if (info.gotSize)
4104 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4105 proportion, flag, border, data);
4106 else
4107 return NULL;
4108 }
4109 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4110
4111 wxPyUserData* data = NULL;
4112 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4113 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4114 if ( userData && (info.window || info.sizer || info.gotSize) )
4115 data = new wxPyUserData(userData);
4116 if ( info.sizer )
4117 PyObject_SetAttrString(item,"thisown",Py_False);
4118 wxPyEndBlockThreads(blocked);
4119
4120 // Now call the real Prepend method if a valid item type was found
4121 if ( info.window )
4122 return self->Prepend(info.window, proportion, flag, border, data);
4123 else if ( info.sizer )
4124 return self->Prepend(info.sizer, proportion, flag, border, data);
4125 else if (info.gotSize)
4126 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4127 proportion, flag, border, data);
4128 else
4129 return NULL;
4130 }
4131 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4134 wxPyEndBlockThreads(blocked);
4135 if ( info.window )
4136 return self->Remove(info.window);
4137 else if ( info.sizer )
4138 return self->Remove(info.sizer);
4139 else if ( info.gotPos )
4140 return self->Remove(info.pos);
4141 else
4142 return false;
4143 }
4144 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4145 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4146 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4147 wxPyEndBlockThreads(blocked);
4148 if ( info.window )
4149 return self->Detach(info.window);
4150 else if ( info.sizer )
4151 return self->Detach(info.sizer);
4152 else if ( info.gotPos )
4153 return self->Detach(info.pos);
4154 else
4155 return false;
4156 }
4157 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4160 wxPyEndBlockThreads(blocked);
4161 if ( info.window )
4162 return self->GetItem(info.window);
4163 else if ( info.sizer )
4164 return self->GetItem(info.sizer);
4165 else if ( info.gotPos )
4166 return self->GetItem(info.pos);
4167 else
4168 return NULL;
4169 }
4170 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4172 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4173 wxPyEndBlockThreads(blocked);
4174 if ( info.window )
4175 self->SetItemMinSize(info.window, size);
4176 else if ( info.sizer )
4177 self->SetItemMinSize(info.sizer, size);
4178 else if ( info.gotPos )
4179 self->SetItemMinSize(info.pos, size);
4180 }
4181 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4182 wxSizerItemList& list = self->GetChildren();
4183 return wxPy_ConvertList(&list);
4184 }
4185 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4188 wxPyEndBlockThreads(blocked);
4189 if ( info.window )
4190 return self->Show(info.window, show, recursive);
4191 else if ( info.sizer )
4192 return self->Show(info.sizer, show, recursive);
4193 else if ( info.gotPos )
4194 return self->Show(info.pos, show);
4195 else
4196 return false;
4197 }
4198 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4199 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4200 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4201 wxPyEndBlockThreads(blocked);
4202 if ( info.window )
4203 return self->IsShown(info.window);
4204 else if ( info.sizer )
4205 return self->IsShown(info.sizer);
4206 else if ( info.gotPos )
4207 return self->IsShown(info.pos);
4208 else
4209 return false;
4210 }
4211
4212 // See pyclasses.h
4213 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4214 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4215 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4216
4217
4218
4219
4220 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4221 {
4222 if (source == Py_None) {
4223 **obj = wxGBPosition(-1,-1);
4224 return true;
4225 }
4226 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4227 }
4228
4229 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4230 {
4231 if (source == Py_None) {
4232 **obj = wxGBSpan(-1,-1);
4233 return true;
4234 }
4235 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4236 }
4237
4238
4239 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4240 wxGBPosition temp, *obj = &temp;
4241 if ( other == Py_None ) return false;
4242 if ( ! wxGBPosition_helper(other, &obj) ) {
4243 PyErr_Clear();
4244 return false;
4245 }
4246 return self->operator==(*obj);
4247 }
4248 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4249 wxGBPosition temp, *obj = &temp;
4250 if ( other == Py_None ) return true;
4251 if ( ! wxGBPosition_helper(other, &obj)) {
4252 PyErr_Clear();
4253 return true;
4254 }
4255 return self->operator!=(*obj);
4256 }
4257 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4258 self->SetRow(row);
4259 self->SetCol(col);
4260 }
4261 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4262 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4263 PyObject* tup = PyTuple_New(2);
4264 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4265 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4266 wxPyEndBlockThreads(blocked);
4267 return tup;
4268 }
4269 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4270 wxGBSpan temp, *obj = &temp;
4271 if ( other == Py_None ) return false;
4272 if ( ! wxGBSpan_helper(other, &obj) ) {
4273 PyErr_Clear();
4274 return false;
4275 }
4276 return self->operator==(*obj);
4277 }
4278 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4279 wxGBSpan temp, *obj = &temp;
4280 if ( other == Py_None ) return true;
4281 if ( ! wxGBSpan_helper(other, &obj)) {
4282 PyErr_Clear();
4283 return true;
4284 }
4285 return self->operator!=(*obj);
4286 }
4287 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4288 self->SetRowspan(rowspan);
4289 self->SetColspan(colspan);
4290 }
4291 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4293 PyObject* tup = PyTuple_New(2);
4294 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4295 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4296 wxPyEndBlockThreads(blocked);
4297 return tup;
4298 }
4299 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4300 wxPyUserData* data = NULL;
4301 if ( userData ) {
4302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4303 data = new wxPyUserData(userData);
4304 wxPyEndBlockThreads(blocked);
4305 }
4306 return new wxGBSizerItem(window, pos, span, flag, border, data);
4307 }
4308 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4309 wxPyUserData* data = NULL;
4310 if ( userData ) {
4311 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4312 data = new wxPyUserData(userData);
4313 wxPyEndBlockThreads(blocked);
4314 }
4315 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4316 }
4317 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4318 wxPyUserData* data = NULL;
4319 if ( userData ) {
4320 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4321 data = new wxPyUserData(userData);
4322 wxPyEndBlockThreads(blocked);
4323 }
4324 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4325 }
4326 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4327 int row, col;
4328 self->GetEndPos(row, col);
4329 return wxGBPosition(row, col);
4330 }
4331 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4332
4333 wxPyUserData* data = NULL;
4334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4335 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4336 if ( userData && (info.window || info.sizer || info.gotSize) )
4337 data = new wxPyUserData(userData);
4338 if ( info.sizer )
4339 PyObject_SetAttrString(item,"thisown",Py_False);
4340 wxPyEndBlockThreads(blocked);
4341
4342 // Now call the real Add method if a valid item type was found
4343 if ( info.window )
4344 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4345 else if ( info.sizer )
4346 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4347 else if (info.gotSize)
4348 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4349 pos, span, flag, border, data);
4350 return NULL;
4351 }
4352
4353
4354 #ifdef __cplusplus
4355 extern "C" {
4356 #endif
4357 SWIGINTERN int EmptyString_set(PyObject *) {
4358 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4359 return 1;
4360 }
4361
4362
4363 SWIGINTERN PyObject *EmptyString_get(void) {
4364 PyObject *pyobj = 0;
4365
4366 {
4367 #if wxUSE_UNICODE
4368 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4369 #else
4370 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4371 #endif
4372 }
4373 return pyobj;
4374 }
4375
4376
4377 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4378 PyObject *resultobj = 0;
4379 wxObject *arg1 = (wxObject *) 0 ;
4380 wxString result;
4381 void *argp1 = 0 ;
4382 int res1 = 0 ;
4383 PyObject *swig_obj[1] ;
4384
4385 if (!args) SWIG_fail;
4386 swig_obj[0] = args;
4387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4388 if (!SWIG_IsOK(res1)) {
4389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4390 }
4391 arg1 = reinterpret_cast< wxObject * >(argp1);
4392 {
4393 PyThreadState* __tstate = wxPyBeginAllowThreads();
4394 result = wxObject_GetClassName(arg1);
4395 wxPyEndAllowThreads(__tstate);
4396 if (PyErr_Occurred()) SWIG_fail;
4397 }
4398 {
4399 #if wxUSE_UNICODE
4400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4401 #else
4402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4403 #endif
4404 }
4405 return resultobj;
4406 fail:
4407 return NULL;
4408 }
4409
4410
4411 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4412 PyObject *resultobj = 0;
4413 wxObject *arg1 = (wxObject *) 0 ;
4414 void *argp1 = 0 ;
4415 int res1 = 0 ;
4416 PyObject *swig_obj[1] ;
4417
4418 if (!args) SWIG_fail;
4419 swig_obj[0] = args;
4420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4421 if (!SWIG_IsOK(res1)) {
4422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4423 }
4424 arg1 = reinterpret_cast< wxObject * >(argp1);
4425 {
4426 PyThreadState* __tstate = wxPyBeginAllowThreads();
4427 wxObject_Destroy(arg1);
4428 wxPyEndAllowThreads(__tstate);
4429 if (PyErr_Occurred()) SWIG_fail;
4430 }
4431 resultobj = SWIG_Py_Void();
4432 return resultobj;
4433 fail:
4434 return NULL;
4435 }
4436
4437
4438 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4439 PyObject *obj;
4440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4441 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4442 return SWIG_Py_Void();
4443 }
4444
4445 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4446 PyObject *resultobj = 0;
4447 wxSize *arg1 = (wxSize *) 0 ;
4448 int arg2 ;
4449 void *argp1 = 0 ;
4450 int res1 = 0 ;
4451 int val2 ;
4452 int ecode2 = 0 ;
4453 PyObject *swig_obj[2] ;
4454
4455 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4459 }
4460 arg1 = reinterpret_cast< wxSize * >(argp1);
4461 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4462 if (!SWIG_IsOK(ecode2)) {
4463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4464 }
4465 arg2 = static_cast< int >(val2);
4466 if (arg1) (arg1)->x = arg2;
4467
4468 resultobj = SWIG_Py_Void();
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *resultobj = 0;
4477 wxSize *arg1 = (wxSize *) 0 ;
4478 int result;
4479 void *argp1 = 0 ;
4480 int res1 = 0 ;
4481 PyObject *swig_obj[1] ;
4482
4483 if (!args) SWIG_fail;
4484 swig_obj[0] = args;
4485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4486 if (!SWIG_IsOK(res1)) {
4487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4488 }
4489 arg1 = reinterpret_cast< wxSize * >(argp1);
4490 result = (int) ((arg1)->x);
4491 resultobj = SWIG_From_int(static_cast< int >(result));
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4499 PyObject *resultobj = 0;
4500 wxSize *arg1 = (wxSize *) 0 ;
4501 int arg2 ;
4502 void *argp1 = 0 ;
4503 int res1 = 0 ;
4504 int val2 ;
4505 int ecode2 = 0 ;
4506 PyObject *swig_obj[2] ;
4507
4508 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4510 if (!SWIG_IsOK(res1)) {
4511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4512 }
4513 arg1 = reinterpret_cast< wxSize * >(argp1);
4514 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4515 if (!SWIG_IsOK(ecode2)) {
4516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4517 }
4518 arg2 = static_cast< int >(val2);
4519 if (arg1) (arg1)->y = arg2;
4520
4521 resultobj = SWIG_Py_Void();
4522 return resultobj;
4523 fail:
4524 return NULL;
4525 }
4526
4527
4528 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4529 PyObject *resultobj = 0;
4530 wxSize *arg1 = (wxSize *) 0 ;
4531 int result;
4532 void *argp1 = 0 ;
4533 int res1 = 0 ;
4534 PyObject *swig_obj[1] ;
4535
4536 if (!args) SWIG_fail;
4537 swig_obj[0] = args;
4538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4539 if (!SWIG_IsOK(res1)) {
4540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4541 }
4542 arg1 = reinterpret_cast< wxSize * >(argp1);
4543 result = (int) ((arg1)->y);
4544 resultobj = SWIG_From_int(static_cast< int >(result));
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4552 PyObject *resultobj = 0;
4553 int arg1 = (int) 0 ;
4554 int arg2 = (int) 0 ;
4555 wxSize *result = 0 ;
4556 int val1 ;
4557 int ecode1 = 0 ;
4558 int val2 ;
4559 int ecode2 = 0 ;
4560 PyObject * obj0 = 0 ;
4561 PyObject * obj1 = 0 ;
4562 char * kwnames[] = {
4563 (char *) "w",(char *) "h", NULL
4564 };
4565
4566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4567 if (obj0) {
4568 ecode1 = SWIG_AsVal_int(obj0, &val1);
4569 if (!SWIG_IsOK(ecode1)) {
4570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4571 }
4572 arg1 = static_cast< int >(val1);
4573 }
4574 if (obj1) {
4575 ecode2 = SWIG_AsVal_int(obj1, &val2);
4576 if (!SWIG_IsOK(ecode2)) {
4577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4578 }
4579 arg2 = static_cast< int >(val2);
4580 }
4581 {
4582 PyThreadState* __tstate = wxPyBeginAllowThreads();
4583 result = (wxSize *)new wxSize(arg1,arg2);
4584 wxPyEndAllowThreads(__tstate);
4585 if (PyErr_Occurred()) SWIG_fail;
4586 }
4587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4588 return resultobj;
4589 fail:
4590 return NULL;
4591 }
4592
4593
4594 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 PyObject *resultobj = 0;
4596 wxSize *arg1 = (wxSize *) 0 ;
4597 void *argp1 = 0 ;
4598 int res1 = 0 ;
4599 PyObject *swig_obj[1] ;
4600
4601 if (!args) SWIG_fail;
4602 swig_obj[0] = args;
4603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4604 if (!SWIG_IsOK(res1)) {
4605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4606 }
4607 arg1 = reinterpret_cast< wxSize * >(argp1);
4608 {
4609 PyThreadState* __tstate = wxPyBeginAllowThreads();
4610 delete arg1;
4611
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 resultobj = SWIG_Py_Void();
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4623 PyObject *resultobj = 0;
4624 wxSize *arg1 = (wxSize *) 0 ;
4625 PyObject *arg2 = (PyObject *) 0 ;
4626 bool result;
4627 void *argp1 = 0 ;
4628 int res1 = 0 ;
4629 PyObject * obj0 = 0 ;
4630 PyObject * obj1 = 0 ;
4631 char * kwnames[] = {
4632 (char *) "self",(char *) "other", NULL
4633 };
4634
4635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4637 if (!SWIG_IsOK(res1)) {
4638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4639 }
4640 arg1 = reinterpret_cast< wxSize * >(argp1);
4641 arg2 = obj1;
4642 {
4643 result = (bool)wxSize___eq__(arg1,arg2);
4644 if (PyErr_Occurred()) SWIG_fail;
4645 }
4646 {
4647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4648 }
4649 return resultobj;
4650 fail:
4651 return NULL;
4652 }
4653
4654
4655 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4656 PyObject *resultobj = 0;
4657 wxSize *arg1 = (wxSize *) 0 ;
4658 PyObject *arg2 = (PyObject *) 0 ;
4659 bool result;
4660 void *argp1 = 0 ;
4661 int res1 = 0 ;
4662 PyObject * obj0 = 0 ;
4663 PyObject * obj1 = 0 ;
4664 char * kwnames[] = {
4665 (char *) "self",(char *) "other", NULL
4666 };
4667
4668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4670 if (!SWIG_IsOK(res1)) {
4671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4672 }
4673 arg1 = reinterpret_cast< wxSize * >(argp1);
4674 arg2 = obj1;
4675 {
4676 result = (bool)wxSize___ne__(arg1,arg2);
4677 if (PyErr_Occurred()) SWIG_fail;
4678 }
4679 {
4680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4681 }
4682 return resultobj;
4683 fail:
4684 return NULL;
4685 }
4686
4687
4688 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4689 PyObject *resultobj = 0;
4690 wxSize *arg1 = (wxSize *) 0 ;
4691 wxSize *arg2 = 0 ;
4692 wxSize result;
4693 void *argp1 = 0 ;
4694 int res1 = 0 ;
4695 wxSize temp2 ;
4696 PyObject * obj0 = 0 ;
4697 PyObject * obj1 = 0 ;
4698 char * kwnames[] = {
4699 (char *) "self",(char *) "sz", NULL
4700 };
4701
4702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4704 if (!SWIG_IsOK(res1)) {
4705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4706 }
4707 arg1 = reinterpret_cast< wxSize * >(argp1);
4708 {
4709 arg2 = &temp2;
4710 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4711 }
4712 {
4713 PyThreadState* __tstate = wxPyBeginAllowThreads();
4714 result = (arg1)->operator +((wxSize const &)*arg2);
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj = 0;
4727 wxSize *arg1 = (wxSize *) 0 ;
4728 wxSize *arg2 = 0 ;
4729 wxSize result;
4730 void *argp1 = 0 ;
4731 int res1 = 0 ;
4732 wxSize temp2 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "sz", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4743 }
4744 arg1 = reinterpret_cast< wxSize * >(argp1);
4745 {
4746 arg2 = &temp2;
4747 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4748 }
4749 {
4750 PyThreadState* __tstate = wxPyBeginAllowThreads();
4751 result = (arg1)->operator -((wxSize const &)*arg2);
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj = 0;
4764 wxSize *arg1 = (wxSize *) 0 ;
4765 wxSize *arg2 = 0 ;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 (arg1)->IncTo((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_Py_Void();
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->DecTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 int arg2 ;
4838 int arg3 ;
4839 void *argp1 = 0 ;
4840 int res1 = 0 ;
4841 int val2 ;
4842 int ecode2 = 0 ;
4843 int val3 ;
4844 int ecode3 = 0 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 PyObject * obj2 = 0 ;
4848 char * kwnames[] = {
4849 (char *) "self",(char *) "w",(char *) "h", NULL
4850 };
4851
4852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4854 if (!SWIG_IsOK(res1)) {
4855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4856 }
4857 arg1 = reinterpret_cast< wxSize * >(argp1);
4858 ecode2 = SWIG_AsVal_int(obj1, &val2);
4859 if (!SWIG_IsOK(ecode2)) {
4860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4861 }
4862 arg2 = static_cast< int >(val2);
4863 ecode3 = SWIG_AsVal_int(obj2, &val3);
4864 if (!SWIG_IsOK(ecode3)) {
4865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4866 }
4867 arg3 = static_cast< int >(val3);
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 (arg1)->Set(arg2,arg3);
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 resultobj = SWIG_Py_Void();
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj = 0;
4883 wxSize *arg1 = (wxSize *) 0 ;
4884 int arg2 ;
4885 void *argp1 = 0 ;
4886 int res1 = 0 ;
4887 int val2 ;
4888 int ecode2 = 0 ;
4889 PyObject * obj0 = 0 ;
4890 PyObject * obj1 = 0 ;
4891 char * kwnames[] = {
4892 (char *) "self",(char *) "w", NULL
4893 };
4894
4895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4897 if (!SWIG_IsOK(res1)) {
4898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4899 }
4900 arg1 = reinterpret_cast< wxSize * >(argp1);
4901 ecode2 = SWIG_AsVal_int(obj1, &val2);
4902 if (!SWIG_IsOK(ecode2)) {
4903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4904 }
4905 arg2 = static_cast< int >(val2);
4906 {
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 (arg1)->SetWidth(arg2);
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 resultobj = SWIG_Py_Void();
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj = 0;
4921 wxSize *arg1 = (wxSize *) 0 ;
4922 int arg2 ;
4923 void *argp1 = 0 ;
4924 int res1 = 0 ;
4925 int val2 ;
4926 int ecode2 = 0 ;
4927 PyObject * obj0 = 0 ;
4928 PyObject * obj1 = 0 ;
4929 char * kwnames[] = {
4930 (char *) "self",(char *) "h", NULL
4931 };
4932
4933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4935 if (!SWIG_IsOK(res1)) {
4936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4937 }
4938 arg1 = reinterpret_cast< wxSize * >(argp1);
4939 ecode2 = SWIG_AsVal_int(obj1, &val2);
4940 if (!SWIG_IsOK(ecode2)) {
4941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4942 }
4943 arg2 = static_cast< int >(val2);
4944 {
4945 PyThreadState* __tstate = wxPyBeginAllowThreads();
4946 (arg1)->SetHeight(arg2);
4947 wxPyEndAllowThreads(__tstate);
4948 if (PyErr_Occurred()) SWIG_fail;
4949 }
4950 resultobj = SWIG_Py_Void();
4951 return resultobj;
4952 fail:
4953 return NULL;
4954 }
4955
4956
4957 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4958 PyObject *resultobj = 0;
4959 wxSize *arg1 = (wxSize *) 0 ;
4960 int result;
4961 void *argp1 = 0 ;
4962 int res1 = 0 ;
4963 PyObject *swig_obj[1] ;
4964
4965 if (!args) SWIG_fail;
4966 swig_obj[0] = args;
4967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4968 if (!SWIG_IsOK(res1)) {
4969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4970 }
4971 arg1 = reinterpret_cast< wxSize * >(argp1);
4972 {
4973 PyThreadState* __tstate = wxPyBeginAllowThreads();
4974 result = (int)((wxSize const *)arg1)->GetWidth();
4975 wxPyEndAllowThreads(__tstate);
4976 if (PyErr_Occurred()) SWIG_fail;
4977 }
4978 resultobj = SWIG_From_int(static_cast< int >(result));
4979 return resultobj;
4980 fail:
4981 return NULL;
4982 }
4983
4984
4985 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4986 PyObject *resultobj = 0;
4987 wxSize *arg1 = (wxSize *) 0 ;
4988 int result;
4989 void *argp1 = 0 ;
4990 int res1 = 0 ;
4991 PyObject *swig_obj[1] ;
4992
4993 if (!args) SWIG_fail;
4994 swig_obj[0] = args;
4995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4996 if (!SWIG_IsOK(res1)) {
4997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4998 }
4999 arg1 = reinterpret_cast< wxSize * >(argp1);
5000 {
5001 PyThreadState* __tstate = wxPyBeginAllowThreads();
5002 result = (int)((wxSize const *)arg1)->GetHeight();
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 resultobj = SWIG_From_int(static_cast< int >(result));
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5014 PyObject *resultobj = 0;
5015 wxSize *arg1 = (wxSize *) 0 ;
5016 bool result;
5017 void *argp1 = 0 ;
5018 int res1 = 0 ;
5019 PyObject *swig_obj[1] ;
5020
5021 if (!args) SWIG_fail;
5022 swig_obj[0] = args;
5023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5024 if (!SWIG_IsOK(res1)) {
5025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5026 }
5027 arg1 = reinterpret_cast< wxSize * >(argp1);
5028 {
5029 PyThreadState* __tstate = wxPyBeginAllowThreads();
5030 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5031 wxPyEndAllowThreads(__tstate);
5032 if (PyErr_Occurred()) SWIG_fail;
5033 }
5034 {
5035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5036 }
5037 return resultobj;
5038 fail:
5039 return NULL;
5040 }
5041
5042
5043 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5044 PyObject *resultobj = 0;
5045 wxSize *arg1 = (wxSize *) 0 ;
5046 wxSize *arg2 = 0 ;
5047 void *argp1 = 0 ;
5048 int res1 = 0 ;
5049 wxSize temp2 ;
5050 PyObject * obj0 = 0 ;
5051 PyObject * obj1 = 0 ;
5052 char * kwnames[] = {
5053 (char *) "self",(char *) "size", NULL
5054 };
5055
5056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5058 if (!SWIG_IsOK(res1)) {
5059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5060 }
5061 arg1 = reinterpret_cast< wxSize * >(argp1);
5062 {
5063 arg2 = &temp2;
5064 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5065 }
5066 {
5067 PyThreadState* __tstate = wxPyBeginAllowThreads();
5068 (arg1)->SetDefaults((wxSize const &)*arg2);
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 resultobj = SWIG_Py_Void();
5073 return resultobj;
5074 fail:
5075 return NULL;
5076 }
5077
5078
5079 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5080 PyObject *resultobj = 0;
5081 wxSize *arg1 = (wxSize *) 0 ;
5082 PyObject *result = 0 ;
5083 void *argp1 = 0 ;
5084 int res1 = 0 ;
5085 PyObject *swig_obj[1] ;
5086
5087 if (!args) SWIG_fail;
5088 swig_obj[0] = args;
5089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5090 if (!SWIG_IsOK(res1)) {
5091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5092 }
5093 arg1 = reinterpret_cast< wxSize * >(argp1);
5094 {
5095 PyThreadState* __tstate = wxPyBeginAllowThreads();
5096 result = (PyObject *)wxSize_Get(arg1);
5097 wxPyEndAllowThreads(__tstate);
5098 if (PyErr_Occurred()) SWIG_fail;
5099 }
5100 resultobj = result;
5101 return resultobj;
5102 fail:
5103 return NULL;
5104 }
5105
5106
5107 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5108 PyObject *obj;
5109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5110 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5111 return SWIG_Py_Void();
5112 }
5113
5114 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5115 return SWIG_Python_InitShadowInstance(args);
5116 }
5117
5118 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119 PyObject *resultobj = 0;
5120 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5121 double arg2 ;
5122 void *argp1 = 0 ;
5123 int res1 = 0 ;
5124 double val2 ;
5125 int ecode2 = 0 ;
5126 PyObject *swig_obj[2] ;
5127
5128 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5130 if (!SWIG_IsOK(res1)) {
5131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5132 }
5133 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5134 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5135 if (!SWIG_IsOK(ecode2)) {
5136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5137 }
5138 arg2 = static_cast< double >(val2);
5139 if (arg1) (arg1)->x = arg2;
5140
5141 resultobj = SWIG_Py_Void();
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5151 double result;
5152 void *argp1 = 0 ;
5153 int res1 = 0 ;
5154 PyObject *swig_obj[1] ;
5155
5156 if (!args) SWIG_fail;
5157 swig_obj[0] = args;
5158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5159 if (!SWIG_IsOK(res1)) {
5160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5161 }
5162 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5163 result = (double) ((arg1)->x);
5164 resultobj = SWIG_From_double(static_cast< double >(result));
5165 return resultobj;
5166 fail:
5167 return NULL;
5168 }
5169
5170
5171 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5172 PyObject *resultobj = 0;
5173 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5174 double arg2 ;
5175 void *argp1 = 0 ;
5176 int res1 = 0 ;
5177 double val2 ;
5178 int ecode2 = 0 ;
5179 PyObject *swig_obj[2] ;
5180
5181 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5183 if (!SWIG_IsOK(res1)) {
5184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5185 }
5186 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5187 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5188 if (!SWIG_IsOK(ecode2)) {
5189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5190 }
5191 arg2 = static_cast< double >(val2);
5192 if (arg1) (arg1)->y = arg2;
5193
5194 resultobj = SWIG_Py_Void();
5195 return resultobj;
5196 fail:
5197 return NULL;
5198 }
5199
5200
5201 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5204 double result;
5205 void *argp1 = 0 ;
5206 int res1 = 0 ;
5207 PyObject *swig_obj[1] ;
5208
5209 if (!args) SWIG_fail;
5210 swig_obj[0] = args;
5211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5212 if (!SWIG_IsOK(res1)) {
5213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5214 }
5215 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5216 result = (double) ((arg1)->y);
5217 resultobj = SWIG_From_double(static_cast< double >(result));
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj = 0;
5226 double arg1 = (double) 0.0 ;
5227 double arg2 = (double) 0.0 ;
5228 wxRealPoint *result = 0 ;
5229 double val1 ;
5230 int ecode1 = 0 ;
5231 double val2 ;
5232 int ecode2 = 0 ;
5233 PyObject * obj0 = 0 ;
5234 PyObject * obj1 = 0 ;
5235 char * kwnames[] = {
5236 (char *) "x",(char *) "y", NULL
5237 };
5238
5239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5240 if (obj0) {
5241 ecode1 = SWIG_AsVal_double(obj0, &val1);
5242 if (!SWIG_IsOK(ecode1)) {
5243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5244 }
5245 arg1 = static_cast< double >(val1);
5246 }
5247 if (obj1) {
5248 ecode2 = SWIG_AsVal_double(obj1, &val2);
5249 if (!SWIG_IsOK(ecode2)) {
5250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5251 }
5252 arg2 = static_cast< double >(val2);
5253 }
5254 {
5255 PyThreadState* __tstate = wxPyBeginAllowThreads();
5256 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5257 wxPyEndAllowThreads(__tstate);
5258 if (PyErr_Occurred()) SWIG_fail;
5259 }
5260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5261 return resultobj;
5262 fail:
5263 return NULL;
5264 }
5265
5266
5267 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5268 PyObject *resultobj = 0;
5269 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5270 void *argp1 = 0 ;
5271 int res1 = 0 ;
5272 PyObject *swig_obj[1] ;
5273
5274 if (!args) SWIG_fail;
5275 swig_obj[0] = args;
5276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5279 }
5280 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5281 {
5282 PyThreadState* __tstate = wxPyBeginAllowThreads();
5283 delete arg1;
5284
5285 wxPyEndAllowThreads(__tstate);
5286 if (PyErr_Occurred()) SWIG_fail;
5287 }
5288 resultobj = SWIG_Py_Void();
5289 return resultobj;
5290 fail:
5291 return NULL;
5292 }
5293
5294
5295 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5296 PyObject *resultobj = 0;
5297 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5298 PyObject *arg2 = (PyObject *) 0 ;
5299 bool result;
5300 void *argp1 = 0 ;
5301 int res1 = 0 ;
5302 PyObject * obj0 = 0 ;
5303 PyObject * obj1 = 0 ;
5304 char * kwnames[] = {
5305 (char *) "self",(char *) "other", NULL
5306 };
5307
5308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5310 if (!SWIG_IsOK(res1)) {
5311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5312 }
5313 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5314 arg2 = obj1;
5315 {
5316 result = (bool)wxRealPoint___eq__(arg1,arg2);
5317 if (PyErr_Occurred()) SWIG_fail;
5318 }
5319 {
5320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5321 }
5322 return resultobj;
5323 fail:
5324 return NULL;
5325 }
5326
5327
5328 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5329 PyObject *resultobj = 0;
5330 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5331 PyObject *arg2 = (PyObject *) 0 ;
5332 bool result;
5333 void *argp1 = 0 ;
5334 int res1 = 0 ;
5335 PyObject * obj0 = 0 ;
5336 PyObject * obj1 = 0 ;
5337 char * kwnames[] = {
5338 (char *) "self",(char *) "other", NULL
5339 };
5340
5341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5343 if (!SWIG_IsOK(res1)) {
5344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5345 }
5346 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5347 arg2 = obj1;
5348 {
5349 result = (bool)wxRealPoint___ne__(arg1,arg2);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 {
5353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5354 }
5355 return resultobj;
5356 fail:
5357 return NULL;
5358 }
5359
5360
5361 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5362 PyObject *resultobj = 0;
5363 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5364 wxRealPoint *arg2 = 0 ;
5365 wxRealPoint result;
5366 void *argp1 = 0 ;
5367 int res1 = 0 ;
5368 wxRealPoint temp2 ;
5369 PyObject * obj0 = 0 ;
5370 PyObject * obj1 = 0 ;
5371 char * kwnames[] = {
5372 (char *) "self",(char *) "pt", NULL
5373 };
5374
5375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5377 if (!SWIG_IsOK(res1)) {
5378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5379 }
5380 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5381 {
5382 arg2 = &temp2;
5383 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5384 }
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5392 return resultobj;
5393 fail:
5394 return NULL;
5395 }
5396
5397
5398 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5399 PyObject *resultobj = 0;
5400 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5401 wxRealPoint *arg2 = 0 ;
5402 wxRealPoint result;
5403 void *argp1 = 0 ;
5404 int res1 = 0 ;
5405 wxRealPoint temp2 ;
5406 PyObject * obj0 = 0 ;
5407 PyObject * obj1 = 0 ;
5408 char * kwnames[] = {
5409 (char *) "self",(char *) "pt", NULL
5410 };
5411
5412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5414 if (!SWIG_IsOK(res1)) {
5415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5416 }
5417 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5418 {
5419 arg2 = &temp2;
5420 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5421 }
5422 {
5423 PyThreadState* __tstate = wxPyBeginAllowThreads();
5424 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5425 wxPyEndAllowThreads(__tstate);
5426 if (PyErr_Occurred()) SWIG_fail;
5427 }
5428 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5429 return resultobj;
5430 fail:
5431 return NULL;
5432 }
5433
5434
5435 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5436 PyObject *resultobj = 0;
5437 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5438 double arg2 ;
5439 double arg3 ;
5440 void *argp1 = 0 ;
5441 int res1 = 0 ;
5442 double val2 ;
5443 int ecode2 = 0 ;
5444 double val3 ;
5445 int ecode3 = 0 ;
5446 PyObject * obj0 = 0 ;
5447 PyObject * obj1 = 0 ;
5448 PyObject * obj2 = 0 ;
5449 char * kwnames[] = {
5450 (char *) "self",(char *) "x",(char *) "y", NULL
5451 };
5452
5453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5455 if (!SWIG_IsOK(res1)) {
5456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5457 }
5458 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5459 ecode2 = SWIG_AsVal_double(obj1, &val2);
5460 if (!SWIG_IsOK(ecode2)) {
5461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5462 }
5463 arg2 = static_cast< double >(val2);
5464 ecode3 = SWIG_AsVal_double(obj2, &val3);
5465 if (!SWIG_IsOK(ecode3)) {
5466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5467 }
5468 arg3 = static_cast< double >(val3);
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 wxRealPoint_Set(arg1,arg2,arg3);
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 resultobj = SWIG_Py_Void();
5476 return resultobj;
5477 fail:
5478 return NULL;
5479 }
5480
5481
5482 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5483 PyObject *resultobj = 0;
5484 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5485 PyObject *result = 0 ;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 PyObject *swig_obj[1] ;
5489
5490 if (!args) SWIG_fail;
5491 swig_obj[0] = args;
5492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5493 if (!SWIG_IsOK(res1)) {
5494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5495 }
5496 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5497 {
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 result = (PyObject *)wxRealPoint_Get(arg1);
5500 wxPyEndAllowThreads(__tstate);
5501 if (PyErr_Occurred()) SWIG_fail;
5502 }
5503 resultobj = result;
5504 return resultobj;
5505 fail:
5506 return NULL;
5507 }
5508
5509
5510 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5511 PyObject *obj;
5512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5513 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5514 return SWIG_Py_Void();
5515 }
5516
5517 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5518 return SWIG_Python_InitShadowInstance(args);
5519 }
5520
5521 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522 PyObject *resultobj = 0;
5523 wxPoint *arg1 = (wxPoint *) 0 ;
5524 int arg2 ;
5525 void *argp1 = 0 ;
5526 int res1 = 0 ;
5527 int val2 ;
5528 int ecode2 = 0 ;
5529 PyObject *swig_obj[2] ;
5530
5531 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5533 if (!SWIG_IsOK(res1)) {
5534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5535 }
5536 arg1 = reinterpret_cast< wxPoint * >(argp1);
5537 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5538 if (!SWIG_IsOK(ecode2)) {
5539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5540 }
5541 arg2 = static_cast< int >(val2);
5542 if (arg1) (arg1)->x = arg2;
5543
5544 resultobj = SWIG_Py_Void();
5545 return resultobj;
5546 fail:
5547 return NULL;
5548 }
5549
5550
5551 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5552 PyObject *resultobj = 0;
5553 wxPoint *arg1 = (wxPoint *) 0 ;
5554 int result;
5555 void *argp1 = 0 ;
5556 int res1 = 0 ;
5557 PyObject *swig_obj[1] ;
5558
5559 if (!args) SWIG_fail;
5560 swig_obj[0] = args;
5561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5562 if (!SWIG_IsOK(res1)) {
5563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5564 }
5565 arg1 = reinterpret_cast< wxPoint * >(argp1);
5566 result = (int) ((arg1)->x);
5567 resultobj = SWIG_From_int(static_cast< int >(result));
5568 return resultobj;
5569 fail:
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575 PyObject *resultobj = 0;
5576 wxPoint *arg1 = (wxPoint *) 0 ;
5577 int arg2 ;
5578 void *argp1 = 0 ;
5579 int res1 = 0 ;
5580 int val2 ;
5581 int ecode2 = 0 ;
5582 PyObject *swig_obj[2] ;
5583
5584 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5586 if (!SWIG_IsOK(res1)) {
5587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5588 }
5589 arg1 = reinterpret_cast< wxPoint * >(argp1);
5590 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5591 if (!SWIG_IsOK(ecode2)) {
5592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5593 }
5594 arg2 = static_cast< int >(val2);
5595 if (arg1) (arg1)->y = arg2;
5596
5597 resultobj = SWIG_Py_Void();
5598 return resultobj;
5599 fail:
5600 return NULL;
5601 }
5602
5603
5604 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5605 PyObject *resultobj = 0;
5606 wxPoint *arg1 = (wxPoint *) 0 ;
5607 int result;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 PyObject *swig_obj[1] ;
5611
5612 if (!args) SWIG_fail;
5613 swig_obj[0] = args;
5614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5615 if (!SWIG_IsOK(res1)) {
5616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5617 }
5618 arg1 = reinterpret_cast< wxPoint * >(argp1);
5619 result = (int) ((arg1)->y);
5620 resultobj = SWIG_From_int(static_cast< int >(result));
5621 return resultobj;
5622 fail:
5623 return NULL;
5624 }
5625
5626
5627 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5628 PyObject *resultobj = 0;
5629 int arg1 = (int) 0 ;
5630 int arg2 = (int) 0 ;
5631 wxPoint *result = 0 ;
5632 int val1 ;
5633 int ecode1 = 0 ;
5634 int val2 ;
5635 int ecode2 = 0 ;
5636 PyObject * obj0 = 0 ;
5637 PyObject * obj1 = 0 ;
5638 char * kwnames[] = {
5639 (char *) "x",(char *) "y", NULL
5640 };
5641
5642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5643 if (obj0) {
5644 ecode1 = SWIG_AsVal_int(obj0, &val1);
5645 if (!SWIG_IsOK(ecode1)) {
5646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5647 }
5648 arg1 = static_cast< int >(val1);
5649 }
5650 if (obj1) {
5651 ecode2 = SWIG_AsVal_int(obj1, &val2);
5652 if (!SWIG_IsOK(ecode2)) {
5653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5654 }
5655 arg2 = static_cast< int >(val2);
5656 }
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 result = (wxPoint *)new wxPoint(arg1,arg2);
5660 wxPyEndAllowThreads(__tstate);
5661 if (PyErr_Occurred()) SWIG_fail;
5662 }
5663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5664 return resultobj;
5665 fail:
5666 return NULL;
5667 }
5668
5669
5670 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5671 PyObject *resultobj = 0;
5672 wxPoint *arg1 = (wxPoint *) 0 ;
5673 void *argp1 = 0 ;
5674 int res1 = 0 ;
5675 PyObject *swig_obj[1] ;
5676
5677 if (!args) SWIG_fail;
5678 swig_obj[0] = args;
5679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5680 if (!SWIG_IsOK(res1)) {
5681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5682 }
5683 arg1 = reinterpret_cast< wxPoint * >(argp1);
5684 {
5685 PyThreadState* __tstate = wxPyBeginAllowThreads();
5686 delete arg1;
5687
5688 wxPyEndAllowThreads(__tstate);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 resultobj = SWIG_Py_Void();
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5699 PyObject *resultobj = 0;
5700 wxPoint *arg1 = (wxPoint *) 0 ;
5701 PyObject *arg2 = (PyObject *) 0 ;
5702 bool result;
5703 void *argp1 = 0 ;
5704 int res1 = 0 ;
5705 PyObject * obj0 = 0 ;
5706 PyObject * obj1 = 0 ;
5707 char * kwnames[] = {
5708 (char *) "self",(char *) "other", NULL
5709 };
5710
5711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5713 if (!SWIG_IsOK(res1)) {
5714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5715 }
5716 arg1 = reinterpret_cast< wxPoint * >(argp1);
5717 arg2 = obj1;
5718 {
5719 result = (bool)wxPoint___eq__(arg1,arg2);
5720 if (PyErr_Occurred()) SWIG_fail;
5721 }
5722 {
5723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5724 }
5725 return resultobj;
5726 fail:
5727 return NULL;
5728 }
5729
5730
5731 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5732 PyObject *resultobj = 0;
5733 wxPoint *arg1 = (wxPoint *) 0 ;
5734 PyObject *arg2 = (PyObject *) 0 ;
5735 bool result;
5736 void *argp1 = 0 ;
5737 int res1 = 0 ;
5738 PyObject * obj0 = 0 ;
5739 PyObject * obj1 = 0 ;
5740 char * kwnames[] = {
5741 (char *) "self",(char *) "other", NULL
5742 };
5743
5744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5746 if (!SWIG_IsOK(res1)) {
5747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5748 }
5749 arg1 = reinterpret_cast< wxPoint * >(argp1);
5750 arg2 = obj1;
5751 {
5752 result = (bool)wxPoint___ne__(arg1,arg2);
5753 if (PyErr_Occurred()) SWIG_fail;
5754 }
5755 {
5756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5757 }
5758 return resultobj;
5759 fail:
5760 return NULL;
5761 }
5762
5763
5764 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5765 PyObject *resultobj = 0;
5766 wxPoint *arg1 = (wxPoint *) 0 ;
5767 wxPoint *arg2 = 0 ;
5768 wxPoint result;
5769 void *argp1 = 0 ;
5770 int res1 = 0 ;
5771 wxPoint temp2 ;
5772 PyObject * obj0 = 0 ;
5773 PyObject * obj1 = 0 ;
5774 char * kwnames[] = {
5775 (char *) "self",(char *) "pt", NULL
5776 };
5777
5778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5780 if (!SWIG_IsOK(res1)) {
5781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5782 }
5783 arg1 = reinterpret_cast< wxPoint * >(argp1);
5784 {
5785 arg2 = &temp2;
5786 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5787 }
5788 {
5789 PyThreadState* __tstate = wxPyBeginAllowThreads();
5790 result = (arg1)->operator +((wxPoint const &)*arg2);
5791 wxPyEndAllowThreads(__tstate);
5792 if (PyErr_Occurred()) SWIG_fail;
5793 }
5794 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5795 return resultobj;
5796 fail:
5797 return NULL;
5798 }
5799
5800
5801 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5802 PyObject *resultobj = 0;
5803 wxPoint *arg1 = (wxPoint *) 0 ;
5804 wxPoint *arg2 = 0 ;
5805 wxPoint result;
5806 void *argp1 = 0 ;
5807 int res1 = 0 ;
5808 wxPoint temp2 ;
5809 PyObject * obj0 = 0 ;
5810 PyObject * obj1 = 0 ;
5811 char * kwnames[] = {
5812 (char *) "self",(char *) "pt", NULL
5813 };
5814
5815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5817 if (!SWIG_IsOK(res1)) {
5818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5819 }
5820 arg1 = reinterpret_cast< wxPoint * >(argp1);
5821 {
5822 arg2 = &temp2;
5823 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5824 }
5825 {
5826 PyThreadState* __tstate = wxPyBeginAllowThreads();
5827 result = (arg1)->operator -((wxPoint const &)*arg2);
5828 wxPyEndAllowThreads(__tstate);
5829 if (PyErr_Occurred()) SWIG_fail;
5830 }
5831 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5832 return resultobj;
5833 fail:
5834 return NULL;
5835 }
5836
5837
5838 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5839 PyObject *resultobj = 0;
5840 wxPoint *arg1 = (wxPoint *) 0 ;
5841 wxPoint *arg2 = 0 ;
5842 wxPoint *result = 0 ;
5843 void *argp1 = 0 ;
5844 int res1 = 0 ;
5845 wxPoint temp2 ;
5846 PyObject * obj0 = 0 ;
5847 PyObject * obj1 = 0 ;
5848 char * kwnames[] = {
5849 (char *) "self",(char *) "pt", NULL
5850 };
5851
5852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5854 if (!SWIG_IsOK(res1)) {
5855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5856 }
5857 arg1 = reinterpret_cast< wxPoint * >(argp1);
5858 {
5859 arg2 = &temp2;
5860 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5861 }
5862 {
5863 PyThreadState* __tstate = wxPyBeginAllowThreads();
5864 {
5865 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5866 result = (wxPoint *) &_result_ref;
5867 }
5868 wxPyEndAllowThreads(__tstate);
5869 if (PyErr_Occurred()) SWIG_fail;
5870 }
5871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5872 return resultobj;
5873 fail:
5874 return NULL;
5875 }
5876
5877
5878 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5879 PyObject *resultobj = 0;
5880 wxPoint *arg1 = (wxPoint *) 0 ;
5881 wxPoint *arg2 = 0 ;
5882 wxPoint *result = 0 ;
5883 void *argp1 = 0 ;
5884 int res1 = 0 ;
5885 wxPoint temp2 ;
5886 PyObject * obj0 = 0 ;
5887 PyObject * obj1 = 0 ;
5888 char * kwnames[] = {
5889 (char *) "self",(char *) "pt", NULL
5890 };
5891
5892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5894 if (!SWIG_IsOK(res1)) {
5895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5896 }
5897 arg1 = reinterpret_cast< wxPoint * >(argp1);
5898 {
5899 arg2 = &temp2;
5900 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5901 }
5902 {
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 {
5905 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5906 result = (wxPoint *) &_result_ref;
5907 }
5908 wxPyEndAllowThreads(__tstate);
5909 if (PyErr_Occurred()) SWIG_fail;
5910 }
5911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5912 return resultobj;
5913 fail:
5914 return NULL;
5915 }
5916
5917
5918 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5919 PyObject *resultobj = 0;
5920 wxPoint *arg1 = (wxPoint *) 0 ;
5921 long arg2 ;
5922 long arg3 ;
5923 void *argp1 = 0 ;
5924 int res1 = 0 ;
5925 long val2 ;
5926 int ecode2 = 0 ;
5927 long val3 ;
5928 int ecode3 = 0 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 PyObject * obj2 = 0 ;
5932 char * kwnames[] = {
5933 (char *) "self",(char *) "x",(char *) "y", NULL
5934 };
5935
5936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5938 if (!SWIG_IsOK(res1)) {
5939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5940 }
5941 arg1 = reinterpret_cast< wxPoint * >(argp1);
5942 ecode2 = SWIG_AsVal_long(obj1, &val2);
5943 if (!SWIG_IsOK(ecode2)) {
5944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5945 }
5946 arg2 = static_cast< long >(val2);
5947 ecode3 = SWIG_AsVal_long(obj2, &val3);
5948 if (!SWIG_IsOK(ecode3)) {
5949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5950 }
5951 arg3 = static_cast< long >(val3);
5952 {
5953 PyThreadState* __tstate = wxPyBeginAllowThreads();
5954 wxPoint_Set(arg1,arg2,arg3);
5955 wxPyEndAllowThreads(__tstate);
5956 if (PyErr_Occurred()) SWIG_fail;
5957 }
5958 resultobj = SWIG_Py_Void();
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5966 PyObject *resultobj = 0;
5967 wxPoint *arg1 = (wxPoint *) 0 ;
5968 PyObject *result = 0 ;
5969 void *argp1 = 0 ;
5970 int res1 = 0 ;
5971 PyObject *swig_obj[1] ;
5972
5973 if (!args) SWIG_fail;
5974 swig_obj[0] = args;
5975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5976 if (!SWIG_IsOK(res1)) {
5977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5978 }
5979 arg1 = reinterpret_cast< wxPoint * >(argp1);
5980 {
5981 PyThreadState* __tstate = wxPyBeginAllowThreads();
5982 result = (PyObject *)wxPoint_Get(arg1);
5983 wxPyEndAllowThreads(__tstate);
5984 if (PyErr_Occurred()) SWIG_fail;
5985 }
5986 resultobj = result;
5987 return resultobj;
5988 fail:
5989 return NULL;
5990 }
5991
5992
5993 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5994 PyObject *obj;
5995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5996 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5997 return SWIG_Py_Void();
5998 }
5999
6000 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6001 return SWIG_Python_InitShadowInstance(args);
6002 }
6003
6004 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6005 PyObject *resultobj = 0;
6006 int arg1 = (int) 0 ;
6007 int arg2 = (int) 0 ;
6008 int arg3 = (int) 0 ;
6009 int arg4 = (int) 0 ;
6010 wxRect *result = 0 ;
6011 int val1 ;
6012 int ecode1 = 0 ;
6013 int val2 ;
6014 int ecode2 = 0 ;
6015 int val3 ;
6016 int ecode3 = 0 ;
6017 int val4 ;
6018 int ecode4 = 0 ;
6019 PyObject * obj0 = 0 ;
6020 PyObject * obj1 = 0 ;
6021 PyObject * obj2 = 0 ;
6022 PyObject * obj3 = 0 ;
6023 char * kwnames[] = {
6024 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6025 };
6026
6027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6028 if (obj0) {
6029 ecode1 = SWIG_AsVal_int(obj0, &val1);
6030 if (!SWIG_IsOK(ecode1)) {
6031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6032 }
6033 arg1 = static_cast< int >(val1);
6034 }
6035 if (obj1) {
6036 ecode2 = SWIG_AsVal_int(obj1, &val2);
6037 if (!SWIG_IsOK(ecode2)) {
6038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6039 }
6040 arg2 = static_cast< int >(val2);
6041 }
6042 if (obj2) {
6043 ecode3 = SWIG_AsVal_int(obj2, &val3);
6044 if (!SWIG_IsOK(ecode3)) {
6045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6046 }
6047 arg3 = static_cast< int >(val3);
6048 }
6049 if (obj3) {
6050 ecode4 = SWIG_AsVal_int(obj3, &val4);
6051 if (!SWIG_IsOK(ecode4)) {
6052 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6053 }
6054 arg4 = static_cast< int >(val4);
6055 }
6056 {
6057 PyThreadState* __tstate = wxPyBeginAllowThreads();
6058 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6059 wxPyEndAllowThreads(__tstate);
6060 if (PyErr_Occurred()) SWIG_fail;
6061 }
6062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6063 return resultobj;
6064 fail:
6065 return NULL;
6066 }
6067
6068
6069 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6070 PyObject *resultobj = 0;
6071 wxPoint *arg1 = 0 ;
6072 wxPoint *arg2 = 0 ;
6073 wxRect *result = 0 ;
6074 wxPoint temp1 ;
6075 wxPoint temp2 ;
6076 PyObject * obj0 = 0 ;
6077 PyObject * obj1 = 0 ;
6078 char * kwnames[] = {
6079 (char *) "topLeft",(char *) "bottomRight", NULL
6080 };
6081
6082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6083 {
6084 arg1 = &temp1;
6085 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6086 }
6087 {
6088 arg2 = &temp2;
6089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6090 }
6091 {
6092 PyThreadState* __tstate = wxPyBeginAllowThreads();
6093 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6094 wxPyEndAllowThreads(__tstate);
6095 if (PyErr_Occurred()) SWIG_fail;
6096 }
6097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6098 return resultobj;
6099 fail:
6100 return NULL;
6101 }
6102
6103
6104 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6105 PyObject *resultobj = 0;
6106 wxPoint *arg1 = 0 ;
6107 wxSize *arg2 = 0 ;
6108 wxRect *result = 0 ;
6109 wxPoint temp1 ;
6110 wxSize temp2 ;
6111 PyObject * obj0 = 0 ;
6112 PyObject * obj1 = 0 ;
6113 char * kwnames[] = {
6114 (char *) "pos",(char *) "size", NULL
6115 };
6116
6117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6118 {
6119 arg1 = &temp1;
6120 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6121 }
6122 {
6123 arg2 = &temp2;
6124 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6125 }
6126 {
6127 PyThreadState* __tstate = wxPyBeginAllowThreads();
6128 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6129 wxPyEndAllowThreads(__tstate);
6130 if (PyErr_Occurred()) SWIG_fail;
6131 }
6132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6133 return resultobj;
6134 fail:
6135 return NULL;
6136 }
6137
6138
6139 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj = 0;
6141 wxSize *arg1 = 0 ;
6142 wxRect *result = 0 ;
6143 wxSize temp1 ;
6144 PyObject * obj0 = 0 ;
6145 char * kwnames[] = {
6146 (char *) "size", NULL
6147 };
6148
6149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6150 {
6151 arg1 = &temp1;
6152 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6153 }
6154 {
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6157 wxPyEndAllowThreads(__tstate);
6158 if (PyErr_Occurred()) SWIG_fail;
6159 }
6160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6161 return resultobj;
6162 fail:
6163 return NULL;
6164 }
6165
6166
6167 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6168 PyObject *resultobj = 0;
6169 wxRect *arg1 = (wxRect *) 0 ;
6170 void *argp1 = 0 ;
6171 int res1 = 0 ;
6172 PyObject *swig_obj[1] ;
6173
6174 if (!args) SWIG_fail;
6175 swig_obj[0] = args;
6176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6177 if (!SWIG_IsOK(res1)) {
6178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6179 }
6180 arg1 = reinterpret_cast< wxRect * >(argp1);
6181 {
6182 PyThreadState* __tstate = wxPyBeginAllowThreads();
6183 delete arg1;
6184
6185 wxPyEndAllowThreads(__tstate);
6186 if (PyErr_Occurred()) SWIG_fail;
6187 }
6188 resultobj = SWIG_Py_Void();
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6196 PyObject *resultobj = 0;
6197 wxRect *arg1 = (wxRect *) 0 ;
6198 int result;
6199 void *argp1 = 0 ;
6200 int res1 = 0 ;
6201 PyObject *swig_obj[1] ;
6202
6203 if (!args) SWIG_fail;
6204 swig_obj[0] = args;
6205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6206 if (!SWIG_IsOK(res1)) {
6207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6208 }
6209 arg1 = reinterpret_cast< wxRect * >(argp1);
6210 {
6211 PyThreadState* __tstate = wxPyBeginAllowThreads();
6212 result = (int)((wxRect const *)arg1)->GetX();
6213 wxPyEndAllowThreads(__tstate);
6214 if (PyErr_Occurred()) SWIG_fail;
6215 }
6216 resultobj = SWIG_From_int(static_cast< int >(result));
6217 return resultobj;
6218 fail:
6219 return NULL;
6220 }
6221
6222
6223 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6224 PyObject *resultobj = 0;
6225 wxRect *arg1 = (wxRect *) 0 ;
6226 int arg2 ;
6227 void *argp1 = 0 ;
6228 int res1 = 0 ;
6229 int val2 ;
6230 int ecode2 = 0 ;
6231 PyObject * obj0 = 0 ;
6232 PyObject * obj1 = 0 ;
6233 char * kwnames[] = {
6234 (char *) "self",(char *) "x", NULL
6235 };
6236
6237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6239 if (!SWIG_IsOK(res1)) {
6240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6241 }
6242 arg1 = reinterpret_cast< wxRect * >(argp1);
6243 ecode2 = SWIG_AsVal_int(obj1, &val2);
6244 if (!SWIG_IsOK(ecode2)) {
6245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6246 }
6247 arg2 = static_cast< int >(val2);
6248 {
6249 PyThreadState* __tstate = wxPyBeginAllowThreads();
6250 (arg1)->SetX(arg2);
6251 wxPyEndAllowThreads(__tstate);
6252 if (PyErr_Occurred()) SWIG_fail;
6253 }
6254 resultobj = SWIG_Py_Void();
6255 return resultobj;
6256 fail:
6257 return NULL;
6258 }
6259
6260
6261 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6262 PyObject *resultobj = 0;
6263 wxRect *arg1 = (wxRect *) 0 ;
6264 int result;
6265 void *argp1 = 0 ;
6266 int res1 = 0 ;
6267 PyObject *swig_obj[1] ;
6268
6269 if (!args) SWIG_fail;
6270 swig_obj[0] = args;
6271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6272 if (!SWIG_IsOK(res1)) {
6273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6274 }
6275 arg1 = reinterpret_cast< wxRect * >(argp1);
6276 {
6277 PyThreadState* __tstate = wxPyBeginAllowThreads();
6278 result = (int)(arg1)->GetY();
6279 wxPyEndAllowThreads(__tstate);
6280 if (PyErr_Occurred()) SWIG_fail;
6281 }
6282 resultobj = SWIG_From_int(static_cast< int >(result));
6283 return resultobj;
6284 fail:
6285 return NULL;
6286 }
6287
6288
6289 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6290 PyObject *resultobj = 0;
6291 wxRect *arg1 = (wxRect *) 0 ;
6292 int arg2 ;
6293 void *argp1 = 0 ;
6294 int res1 = 0 ;
6295 int val2 ;
6296 int ecode2 = 0 ;
6297 PyObject * obj0 = 0 ;
6298 PyObject * obj1 = 0 ;
6299 char * kwnames[] = {
6300 (char *) "self",(char *) "y", NULL
6301 };
6302
6303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6305 if (!SWIG_IsOK(res1)) {
6306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6307 }
6308 arg1 = reinterpret_cast< wxRect * >(argp1);
6309 ecode2 = SWIG_AsVal_int(obj1, &val2);
6310 if (!SWIG_IsOK(ecode2)) {
6311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6312 }
6313 arg2 = static_cast< int >(val2);
6314 {
6315 PyThreadState* __tstate = wxPyBeginAllowThreads();
6316 (arg1)->SetY(arg2);
6317 wxPyEndAllowThreads(__tstate);
6318 if (PyErr_Occurred()) SWIG_fail;
6319 }
6320 resultobj = SWIG_Py_Void();
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6328 PyObject *resultobj = 0;
6329 wxRect *arg1 = (wxRect *) 0 ;
6330 int result;
6331 void *argp1 = 0 ;
6332 int res1 = 0 ;
6333 PyObject *swig_obj[1] ;
6334
6335 if (!args) SWIG_fail;
6336 swig_obj[0] = args;
6337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6338 if (!SWIG_IsOK(res1)) {
6339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6340 }
6341 arg1 = reinterpret_cast< wxRect * >(argp1);
6342 {
6343 PyThreadState* __tstate = wxPyBeginAllowThreads();
6344 result = (int)((wxRect const *)arg1)->GetWidth();
6345 wxPyEndAllowThreads(__tstate);
6346 if (PyErr_Occurred()) SWIG_fail;
6347 }
6348 resultobj = SWIG_From_int(static_cast< int >(result));
6349 return resultobj;
6350 fail:
6351 return NULL;
6352 }
6353
6354
6355 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6356 PyObject *resultobj = 0;
6357 wxRect *arg1 = (wxRect *) 0 ;
6358 int arg2 ;
6359 void *argp1 = 0 ;
6360 int res1 = 0 ;
6361 int val2 ;
6362 int ecode2 = 0 ;
6363 PyObject * obj0 = 0 ;
6364 PyObject * obj1 = 0 ;
6365 char * kwnames[] = {
6366 (char *) "self",(char *) "w", NULL
6367 };
6368
6369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6371 if (!SWIG_IsOK(res1)) {
6372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6373 }
6374 arg1 = reinterpret_cast< wxRect * >(argp1);
6375 ecode2 = SWIG_AsVal_int(obj1, &val2);
6376 if (!SWIG_IsOK(ecode2)) {
6377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6378 }
6379 arg2 = static_cast< int >(val2);
6380 {
6381 PyThreadState* __tstate = wxPyBeginAllowThreads();
6382 (arg1)->SetWidth(arg2);
6383 wxPyEndAllowThreads(__tstate);
6384 if (PyErr_Occurred()) SWIG_fail;
6385 }
6386 resultobj = SWIG_Py_Void();
6387 return resultobj;
6388 fail:
6389 return NULL;
6390 }
6391
6392
6393 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6394 PyObject *resultobj = 0;
6395 wxRect *arg1 = (wxRect *) 0 ;
6396 int result;
6397 void *argp1 = 0 ;
6398 int res1 = 0 ;
6399 PyObject *swig_obj[1] ;
6400
6401 if (!args) SWIG_fail;
6402 swig_obj[0] = args;
6403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6404 if (!SWIG_IsOK(res1)) {
6405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6406 }
6407 arg1 = reinterpret_cast< wxRect * >(argp1);
6408 {
6409 PyThreadState* __tstate = wxPyBeginAllowThreads();
6410 result = (int)((wxRect const *)arg1)->GetHeight();
6411 wxPyEndAllowThreads(__tstate);
6412 if (PyErr_Occurred()) SWIG_fail;
6413 }
6414 resultobj = SWIG_From_int(static_cast< int >(result));
6415 return resultobj;
6416 fail:
6417 return NULL;
6418 }
6419
6420
6421 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj = 0;
6423 wxRect *arg1 = (wxRect *) 0 ;
6424 int arg2 ;
6425 void *argp1 = 0 ;
6426 int res1 = 0 ;
6427 int val2 ;
6428 int ecode2 = 0 ;
6429 PyObject * obj0 = 0 ;
6430 PyObject * obj1 = 0 ;
6431 char * kwnames[] = {
6432 (char *) "self",(char *) "h", NULL
6433 };
6434
6435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6437 if (!SWIG_IsOK(res1)) {
6438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6439 }
6440 arg1 = reinterpret_cast< wxRect * >(argp1);
6441 ecode2 = SWIG_AsVal_int(obj1, &val2);
6442 if (!SWIG_IsOK(ecode2)) {
6443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6444 }
6445 arg2 = static_cast< int >(val2);
6446 {
6447 PyThreadState* __tstate = wxPyBeginAllowThreads();
6448 (arg1)->SetHeight(arg2);
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = SWIG_Py_Void();
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6460 PyObject *resultobj = 0;
6461 wxRect *arg1 = (wxRect *) 0 ;
6462 wxPoint result;
6463 void *argp1 = 0 ;
6464 int res1 = 0 ;
6465 PyObject *swig_obj[1] ;
6466
6467 if (!args) SWIG_fail;
6468 swig_obj[0] = args;
6469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6470 if (!SWIG_IsOK(res1)) {
6471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6472 }
6473 arg1 = reinterpret_cast< wxRect * >(argp1);
6474 {
6475 PyThreadState* __tstate = wxPyBeginAllowThreads();
6476 result = ((wxRect const *)arg1)->GetPosition();
6477 wxPyEndAllowThreads(__tstate);
6478 if (PyErr_Occurred()) SWIG_fail;
6479 }
6480 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6481 return resultobj;
6482 fail:
6483 return NULL;
6484 }
6485
6486
6487 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6488 PyObject *resultobj = 0;
6489 wxRect *arg1 = (wxRect *) 0 ;
6490 wxPoint *arg2 = 0 ;
6491 void *argp1 = 0 ;
6492 int res1 = 0 ;
6493 wxPoint temp2 ;
6494 PyObject * obj0 = 0 ;
6495 PyObject * obj1 = 0 ;
6496 char * kwnames[] = {
6497 (char *) "self",(char *) "p", NULL
6498 };
6499
6500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6502 if (!SWIG_IsOK(res1)) {
6503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6504 }
6505 arg1 = reinterpret_cast< wxRect * >(argp1);
6506 {
6507 arg2 = &temp2;
6508 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6509 }
6510 {
6511 PyThreadState* __tstate = wxPyBeginAllowThreads();
6512 (arg1)->SetPosition((wxPoint const &)*arg2);
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 resultobj = SWIG_Py_Void();
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6524 PyObject *resultobj = 0;
6525 wxRect *arg1 = (wxRect *) 0 ;
6526 wxSize result;
6527 void *argp1 = 0 ;
6528 int res1 = 0 ;
6529 PyObject *swig_obj[1] ;
6530
6531 if (!args) SWIG_fail;
6532 swig_obj[0] = args;
6533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 {
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 result = ((wxRect const *)arg1)->GetSize();
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6545 return resultobj;
6546 fail:
6547 return NULL;
6548 }
6549
6550
6551 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6552 PyObject *resultobj = 0;
6553 wxRect *arg1 = (wxRect *) 0 ;
6554 wxSize *arg2 = 0 ;
6555 void *argp1 = 0 ;
6556 int res1 = 0 ;
6557 wxSize temp2 ;
6558 PyObject * obj0 = 0 ;
6559 PyObject * obj1 = 0 ;
6560 char * kwnames[] = {
6561 (char *) "self",(char *) "s", NULL
6562 };
6563
6564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6566 if (!SWIG_IsOK(res1)) {
6567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6568 }
6569 arg1 = reinterpret_cast< wxRect * >(argp1);
6570 {
6571 arg2 = &temp2;
6572 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6573 }
6574 {
6575 PyThreadState* __tstate = wxPyBeginAllowThreads();
6576 (arg1)->SetSize((wxSize const &)*arg2);
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 resultobj = SWIG_Py_Void();
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6588 PyObject *resultobj = 0;
6589 wxRect *arg1 = (wxRect *) 0 ;
6590 bool result;
6591 void *argp1 = 0 ;
6592 int res1 = 0 ;
6593 PyObject *swig_obj[1] ;
6594
6595 if (!args) SWIG_fail;
6596 swig_obj[0] = args;
6597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6598 if (!SWIG_IsOK(res1)) {
6599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6600 }
6601 arg1 = reinterpret_cast< wxRect * >(argp1);
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 result = (bool)((wxRect const *)arg1)->IsEmpty();
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 {
6609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6610 }
6611 return resultobj;
6612 fail:
6613 return NULL;
6614 }
6615
6616
6617 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6618 PyObject *resultobj = 0;
6619 wxRect *arg1 = (wxRect *) 0 ;
6620 wxPoint result;
6621 void *argp1 = 0 ;
6622 int res1 = 0 ;
6623 PyObject *swig_obj[1] ;
6624
6625 if (!args) SWIG_fail;
6626 swig_obj[0] = args;
6627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6628 if (!SWIG_IsOK(res1)) {
6629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6630 }
6631 arg1 = reinterpret_cast< wxRect * >(argp1);
6632 {
6633 PyThreadState* __tstate = wxPyBeginAllowThreads();
6634 result = ((wxRect const *)arg1)->GetTopLeft();
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6646 PyObject *resultobj = 0;
6647 wxRect *arg1 = (wxRect *) 0 ;
6648 wxPoint *arg2 = 0 ;
6649 void *argp1 = 0 ;
6650 int res1 = 0 ;
6651 wxPoint temp2 ;
6652 PyObject * obj0 = 0 ;
6653 PyObject * obj1 = 0 ;
6654 char * kwnames[] = {
6655 (char *) "self",(char *) "p", NULL
6656 };
6657
6658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6660 if (!SWIG_IsOK(res1)) {
6661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6662 }
6663 arg1 = reinterpret_cast< wxRect * >(argp1);
6664 {
6665 arg2 = &temp2;
6666 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6667 }
6668 {
6669 PyThreadState* __tstate = wxPyBeginAllowThreads();
6670 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6671 wxPyEndAllowThreads(__tstate);
6672 if (PyErr_Occurred()) SWIG_fail;
6673 }
6674 resultobj = SWIG_Py_Void();
6675 return resultobj;
6676 fail:
6677 return NULL;
6678 }
6679
6680
6681 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6682 PyObject *resultobj = 0;
6683 wxRect *arg1 = (wxRect *) 0 ;
6684 wxPoint result;
6685 void *argp1 = 0 ;
6686 int res1 = 0 ;
6687 PyObject *swig_obj[1] ;
6688
6689 if (!args) SWIG_fail;
6690 swig_obj[0] = args;
6691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6692 if (!SWIG_IsOK(res1)) {
6693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6694 }
6695 arg1 = reinterpret_cast< wxRect * >(argp1);
6696 {
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 result = ((wxRect const *)arg1)->GetBottomRight();
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6710 PyObject *resultobj = 0;
6711 wxRect *arg1 = (wxRect *) 0 ;
6712 wxPoint *arg2 = 0 ;
6713 void *argp1 = 0 ;
6714 int res1 = 0 ;
6715 wxPoint temp2 ;
6716 PyObject * obj0 = 0 ;
6717 PyObject * obj1 = 0 ;
6718 char * kwnames[] = {
6719 (char *) "self",(char *) "p", NULL
6720 };
6721
6722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6724 if (!SWIG_IsOK(res1)) {
6725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6726 }
6727 arg1 = reinterpret_cast< wxRect * >(argp1);
6728 {
6729 arg2 = &temp2;
6730 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6731 }
6732 {
6733 PyThreadState* __tstate = wxPyBeginAllowThreads();
6734 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6735 wxPyEndAllowThreads(__tstate);
6736 if (PyErr_Occurred()) SWIG_fail;
6737 }
6738 resultobj = SWIG_Py_Void();
6739 return resultobj;
6740 fail:
6741 return NULL;
6742 }
6743
6744
6745 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6746 PyObject *resultobj = 0;
6747 wxRect *arg1 = (wxRect *) 0 ;
6748 int result;
6749 void *argp1 = 0 ;
6750 int res1 = 0 ;
6751 PyObject *swig_obj[1] ;
6752
6753 if (!args) SWIG_fail;
6754 swig_obj[0] = args;
6755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6756 if (!SWIG_IsOK(res1)) {
6757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6758 }
6759 arg1 = reinterpret_cast< wxRect * >(argp1);
6760 {
6761 PyThreadState* __tstate = wxPyBeginAllowThreads();
6762 result = (int)((wxRect const *)arg1)->GetLeft();
6763 wxPyEndAllowThreads(__tstate);
6764 if (PyErr_Occurred()) SWIG_fail;
6765 }
6766 resultobj = SWIG_From_int(static_cast< int >(result));
6767 return resultobj;
6768 fail:
6769 return NULL;
6770 }
6771
6772
6773 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6774 PyObject *resultobj = 0;
6775 wxRect *arg1 = (wxRect *) 0 ;
6776 int result;
6777 void *argp1 = 0 ;
6778 int res1 = 0 ;
6779 PyObject *swig_obj[1] ;
6780
6781 if (!args) SWIG_fail;
6782 swig_obj[0] = args;
6783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6784 if (!SWIG_IsOK(res1)) {
6785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6786 }
6787 arg1 = reinterpret_cast< wxRect * >(argp1);
6788 {
6789 PyThreadState* __tstate = wxPyBeginAllowThreads();
6790 result = (int)((wxRect const *)arg1)->GetTop();
6791 wxPyEndAllowThreads(__tstate);
6792 if (PyErr_Occurred()) SWIG_fail;
6793 }
6794 resultobj = SWIG_From_int(static_cast< int >(result));
6795 return resultobj;
6796 fail:
6797 return NULL;
6798 }
6799
6800
6801 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6802 PyObject *resultobj = 0;
6803 wxRect *arg1 = (wxRect *) 0 ;
6804 int result;
6805 void *argp1 = 0 ;
6806 int res1 = 0 ;
6807 PyObject *swig_obj[1] ;
6808
6809 if (!args) SWIG_fail;
6810 swig_obj[0] = args;
6811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6812 if (!SWIG_IsOK(res1)) {
6813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6814 }
6815 arg1 = reinterpret_cast< wxRect * >(argp1);
6816 {
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 result = (int)((wxRect const *)arg1)->GetBottom();
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_From_int(static_cast< int >(result));
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 wxRect *arg1 = (wxRect *) 0 ;
6832 int result;
6833 void *argp1 = 0 ;
6834 int res1 = 0 ;
6835 PyObject *swig_obj[1] ;
6836
6837 if (!args) SWIG_fail;
6838 swig_obj[0] = args;
6839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6840 if (!SWIG_IsOK(res1)) {
6841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6842 }
6843 arg1 = reinterpret_cast< wxRect * >(argp1);
6844 {
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 result = (int)((wxRect const *)arg1)->GetRight();
6847 wxPyEndAllowThreads(__tstate);
6848 if (PyErr_Occurred()) SWIG_fail;
6849 }
6850 resultobj = SWIG_From_int(static_cast< int >(result));
6851 return resultobj;
6852 fail:
6853 return NULL;
6854 }
6855
6856
6857 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6858 PyObject *resultobj = 0;
6859 wxRect *arg1 = (wxRect *) 0 ;
6860 int arg2 ;
6861 void *argp1 = 0 ;
6862 int res1 = 0 ;
6863 int val2 ;
6864 int ecode2 = 0 ;
6865 PyObject * obj0 = 0 ;
6866 PyObject * obj1 = 0 ;
6867 char * kwnames[] = {
6868 (char *) "self",(char *) "left", NULL
6869 };
6870
6871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6873 if (!SWIG_IsOK(res1)) {
6874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6875 }
6876 arg1 = reinterpret_cast< wxRect * >(argp1);
6877 ecode2 = SWIG_AsVal_int(obj1, &val2);
6878 if (!SWIG_IsOK(ecode2)) {
6879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6880 }
6881 arg2 = static_cast< int >(val2);
6882 {
6883 PyThreadState* __tstate = wxPyBeginAllowThreads();
6884 (arg1)->SetLeft(arg2);
6885 wxPyEndAllowThreads(__tstate);
6886 if (PyErr_Occurred()) SWIG_fail;
6887 }
6888 resultobj = SWIG_Py_Void();
6889 return resultobj;
6890 fail:
6891 return NULL;
6892 }
6893
6894
6895 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6896 PyObject *resultobj = 0;
6897 wxRect *arg1 = (wxRect *) 0 ;
6898 int arg2 ;
6899 void *argp1 = 0 ;
6900 int res1 = 0 ;
6901 int val2 ;
6902 int ecode2 = 0 ;
6903 PyObject * obj0 = 0 ;
6904 PyObject * obj1 = 0 ;
6905 char * kwnames[] = {
6906 (char *) "self",(char *) "right", NULL
6907 };
6908
6909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6911 if (!SWIG_IsOK(res1)) {
6912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6913 }
6914 arg1 = reinterpret_cast< wxRect * >(argp1);
6915 ecode2 = SWIG_AsVal_int(obj1, &val2);
6916 if (!SWIG_IsOK(ecode2)) {
6917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6918 }
6919 arg2 = static_cast< int >(val2);
6920 {
6921 PyThreadState* __tstate = wxPyBeginAllowThreads();
6922 (arg1)->SetRight(arg2);
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 resultobj = SWIG_Py_Void();
6927 return resultobj;
6928 fail:
6929 return NULL;
6930 }
6931
6932
6933 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6934 PyObject *resultobj = 0;
6935 wxRect *arg1 = (wxRect *) 0 ;
6936 int arg2 ;
6937 void *argp1 = 0 ;
6938 int res1 = 0 ;
6939 int val2 ;
6940 int ecode2 = 0 ;
6941 PyObject * obj0 = 0 ;
6942 PyObject * obj1 = 0 ;
6943 char * kwnames[] = {
6944 (char *) "self",(char *) "top", NULL
6945 };
6946
6947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6949 if (!SWIG_IsOK(res1)) {
6950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6951 }
6952 arg1 = reinterpret_cast< wxRect * >(argp1);
6953 ecode2 = SWIG_AsVal_int(obj1, &val2);
6954 if (!SWIG_IsOK(ecode2)) {
6955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6956 }
6957 arg2 = static_cast< int >(val2);
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 (arg1)->SetTop(arg2);
6961 wxPyEndAllowThreads(__tstate);
6962 if (PyErr_Occurred()) SWIG_fail;
6963 }
6964 resultobj = SWIG_Py_Void();
6965 return resultobj;
6966 fail:
6967 return NULL;
6968 }
6969
6970
6971 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6972 PyObject *resultobj = 0;
6973 wxRect *arg1 = (wxRect *) 0 ;
6974 int arg2 ;
6975 void *argp1 = 0 ;
6976 int res1 = 0 ;
6977 int val2 ;
6978 int ecode2 = 0 ;
6979 PyObject * obj0 = 0 ;
6980 PyObject * obj1 = 0 ;
6981 char * kwnames[] = {
6982 (char *) "self",(char *) "bottom", NULL
6983 };
6984
6985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6987 if (!SWIG_IsOK(res1)) {
6988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6989 }
6990 arg1 = reinterpret_cast< wxRect * >(argp1);
6991 ecode2 = SWIG_AsVal_int(obj1, &val2);
6992 if (!SWIG_IsOK(ecode2)) {
6993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6994 }
6995 arg2 = static_cast< int >(val2);
6996 {
6997 PyThreadState* __tstate = wxPyBeginAllowThreads();
6998 (arg1)->SetBottom(arg2);
6999 wxPyEndAllowThreads(__tstate);
7000 if (PyErr_Occurred()) SWIG_fail;
7001 }
7002 resultobj = SWIG_Py_Void();
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7010 PyObject *resultobj = 0;
7011 wxRect *arg1 = (wxRect *) 0 ;
7012 int arg2 ;
7013 int arg3 ;
7014 wxRect *result = 0 ;
7015 void *argp1 = 0 ;
7016 int res1 = 0 ;
7017 int val2 ;
7018 int ecode2 = 0 ;
7019 int val3 ;
7020 int ecode3 = 0 ;
7021 PyObject * obj0 = 0 ;
7022 PyObject * obj1 = 0 ;
7023 PyObject * obj2 = 0 ;
7024 char * kwnames[] = {
7025 (char *) "self",(char *) "dx",(char *) "dy", NULL
7026 };
7027
7028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7030 if (!SWIG_IsOK(res1)) {
7031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7032 }
7033 arg1 = reinterpret_cast< wxRect * >(argp1);
7034 ecode2 = SWIG_AsVal_int(obj1, &val2);
7035 if (!SWIG_IsOK(ecode2)) {
7036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7037 }
7038 arg2 = static_cast< int >(val2);
7039 ecode3 = SWIG_AsVal_int(obj2, &val3);
7040 if (!SWIG_IsOK(ecode3)) {
7041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7042 }
7043 arg3 = static_cast< int >(val3);
7044 {
7045 PyThreadState* __tstate = wxPyBeginAllowThreads();
7046 {
7047 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7048 result = (wxRect *) &_result_ref;
7049 }
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj = 0;
7062 wxRect *arg1 = (wxRect *) 0 ;
7063 int arg2 ;
7064 int arg3 ;
7065 wxRect *result = 0 ;
7066 void *argp1 = 0 ;
7067 int res1 = 0 ;
7068 int val2 ;
7069 int ecode2 = 0 ;
7070 int val3 ;
7071 int ecode3 = 0 ;
7072 PyObject * obj0 = 0 ;
7073 PyObject * obj1 = 0 ;
7074 PyObject * obj2 = 0 ;
7075 char * kwnames[] = {
7076 (char *) "self",(char *) "dx",(char *) "dy", NULL
7077 };
7078
7079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7081 if (!SWIG_IsOK(res1)) {
7082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7083 }
7084 arg1 = reinterpret_cast< wxRect * >(argp1);
7085 ecode2 = SWIG_AsVal_int(obj1, &val2);
7086 if (!SWIG_IsOK(ecode2)) {
7087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7088 }
7089 arg2 = static_cast< int >(val2);
7090 ecode3 = SWIG_AsVal_int(obj2, &val3);
7091 if (!SWIG_IsOK(ecode3)) {
7092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7093 }
7094 arg3 = static_cast< int >(val3);
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 {
7098 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7099 result = (wxRect *) &_result_ref;
7100 }
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7112 PyObject *resultobj = 0;
7113 wxRect *arg1 = (wxRect *) 0 ;
7114 int arg2 ;
7115 int arg3 ;
7116 void *argp1 = 0 ;
7117 int res1 = 0 ;
7118 int val2 ;
7119 int ecode2 = 0 ;
7120 int val3 ;
7121 int ecode3 = 0 ;
7122 PyObject * obj0 = 0 ;
7123 PyObject * obj1 = 0 ;
7124 PyObject * obj2 = 0 ;
7125 char * kwnames[] = {
7126 (char *) "self",(char *) "dx",(char *) "dy", NULL
7127 };
7128
7129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7131 if (!SWIG_IsOK(res1)) {
7132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7133 }
7134 arg1 = reinterpret_cast< wxRect * >(argp1);
7135 ecode2 = SWIG_AsVal_int(obj1, &val2);
7136 if (!SWIG_IsOK(ecode2)) {
7137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7138 }
7139 arg2 = static_cast< int >(val2);
7140 ecode3 = SWIG_AsVal_int(obj2, &val3);
7141 if (!SWIG_IsOK(ecode3)) {
7142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7143 }
7144 arg3 = static_cast< int >(val3);
7145 {
7146 PyThreadState* __tstate = wxPyBeginAllowThreads();
7147 (arg1)->Offset(arg2,arg3);
7148 wxPyEndAllowThreads(__tstate);
7149 if (PyErr_Occurred()) SWIG_fail;
7150 }
7151 resultobj = SWIG_Py_Void();
7152 return resultobj;
7153 fail:
7154 return NULL;
7155 }
7156
7157
7158 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7159 PyObject *resultobj = 0;
7160 wxRect *arg1 = (wxRect *) 0 ;
7161 wxPoint *arg2 = 0 ;
7162 void *argp1 = 0 ;
7163 int res1 = 0 ;
7164 wxPoint temp2 ;
7165 PyObject * obj0 = 0 ;
7166 PyObject * obj1 = 0 ;
7167 char * kwnames[] = {
7168 (char *) "self",(char *) "pt", NULL
7169 };
7170
7171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7173 if (!SWIG_IsOK(res1)) {
7174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7175 }
7176 arg1 = reinterpret_cast< wxRect * >(argp1);
7177 {
7178 arg2 = &temp2;
7179 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7180 }
7181 {
7182 PyThreadState* __tstate = wxPyBeginAllowThreads();
7183 (arg1)->Offset((wxPoint const &)*arg2);
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 resultobj = SWIG_Py_Void();
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj = 0;
7196 wxRect *arg1 = (wxRect *) 0 ;
7197 wxRect *arg2 = 0 ;
7198 wxRect result;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 wxRect temp2 ;
7202 PyObject * obj0 = 0 ;
7203 PyObject * obj1 = 0 ;
7204 char * kwnames[] = {
7205 (char *) "self",(char *) "rect", NULL
7206 };
7207
7208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7210 if (!SWIG_IsOK(res1)) {
7211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7212 }
7213 arg1 = reinterpret_cast< wxRect * >(argp1);
7214 {
7215 arg2 = &temp2;
7216 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7217 }
7218 {
7219 PyThreadState* __tstate = wxPyBeginAllowThreads();
7220 result = (arg1)->Intersect((wxRect const &)*arg2);
7221 wxPyEndAllowThreads(__tstate);
7222 if (PyErr_Occurred()) SWIG_fail;
7223 }
7224 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7225 return resultobj;
7226 fail:
7227 return NULL;
7228 }
7229
7230
7231 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7232 PyObject *resultobj = 0;
7233 wxRect *arg1 = (wxRect *) 0 ;
7234 wxRect *arg2 = 0 ;
7235 wxRect result;
7236 void *argp1 = 0 ;
7237 int res1 = 0 ;
7238 wxRect temp2 ;
7239 PyObject * obj0 = 0 ;
7240 PyObject * obj1 = 0 ;
7241 char * kwnames[] = {
7242 (char *) "self",(char *) "rect", NULL
7243 };
7244
7245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7247 if (!SWIG_IsOK(res1)) {
7248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7249 }
7250 arg1 = reinterpret_cast< wxRect * >(argp1);
7251 {
7252 arg2 = &temp2;
7253 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7254 }
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 result = (arg1)->Union((wxRect const &)*arg2);
7258 wxPyEndAllowThreads(__tstate);
7259 if (PyErr_Occurred()) SWIG_fail;
7260 }
7261 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj = 0;
7270 wxRect *arg1 = (wxRect *) 0 ;
7271 wxRect *arg2 = 0 ;
7272 wxRect result;
7273 void *argp1 = 0 ;
7274 int res1 = 0 ;
7275 wxRect temp2 ;
7276 PyObject * obj0 = 0 ;
7277 PyObject * obj1 = 0 ;
7278 char * kwnames[] = {
7279 (char *) "self",(char *) "rect", NULL
7280 };
7281
7282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7284 if (!SWIG_IsOK(res1)) {
7285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7286 }
7287 arg1 = reinterpret_cast< wxRect * >(argp1);
7288 {
7289 arg2 = &temp2;
7290 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7291 }
7292 {
7293 PyThreadState* __tstate = wxPyBeginAllowThreads();
7294 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7295 wxPyEndAllowThreads(__tstate);
7296 if (PyErr_Occurred()) SWIG_fail;
7297 }
7298 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7299 return resultobj;
7300 fail:
7301 return NULL;
7302 }
7303
7304
7305 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7306 PyObject *resultobj = 0;
7307 wxRect *arg1 = (wxRect *) 0 ;
7308 wxRect *arg2 = 0 ;
7309 wxRect *result = 0 ;
7310 void *argp1 = 0 ;
7311 int res1 = 0 ;
7312 wxRect temp2 ;
7313 PyObject * obj0 = 0 ;
7314 PyObject * obj1 = 0 ;
7315 char * kwnames[] = {
7316 (char *) "self",(char *) "rect", NULL
7317 };
7318
7319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7321 if (!SWIG_IsOK(res1)) {
7322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7323 }
7324 arg1 = reinterpret_cast< wxRect * >(argp1);
7325 {
7326 arg2 = &temp2;
7327 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7328 }
7329 {
7330 PyThreadState* __tstate = wxPyBeginAllowThreads();
7331 {
7332 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7333 result = (wxRect *) &_result_ref;
7334 }
7335 wxPyEndAllowThreads(__tstate);
7336 if (PyErr_Occurred()) SWIG_fail;
7337 }
7338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7339 return resultobj;
7340 fail:
7341 return NULL;
7342 }
7343
7344
7345 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7346 PyObject *resultobj = 0;
7347 wxRect *arg1 = (wxRect *) 0 ;
7348 PyObject *arg2 = (PyObject *) 0 ;
7349 bool result;
7350 void *argp1 = 0 ;
7351 int res1 = 0 ;
7352 PyObject * obj0 = 0 ;
7353 PyObject * obj1 = 0 ;
7354 char * kwnames[] = {
7355 (char *) "self",(char *) "other", NULL
7356 };
7357
7358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7360 if (!SWIG_IsOK(res1)) {
7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7362 }
7363 arg1 = reinterpret_cast< wxRect * >(argp1);
7364 arg2 = obj1;
7365 {
7366 result = (bool)wxRect___eq__(arg1,arg2);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 {
7370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7371 }
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7379 PyObject *resultobj = 0;
7380 wxRect *arg1 = (wxRect *) 0 ;
7381 PyObject *arg2 = (PyObject *) 0 ;
7382 bool result;
7383 void *argp1 = 0 ;
7384 int res1 = 0 ;
7385 PyObject * obj0 = 0 ;
7386 PyObject * obj1 = 0 ;
7387 char * kwnames[] = {
7388 (char *) "self",(char *) "other", NULL
7389 };
7390
7391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7393 if (!SWIG_IsOK(res1)) {
7394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7395 }
7396 arg1 = reinterpret_cast< wxRect * >(argp1);
7397 arg2 = obj1;
7398 {
7399 result = (bool)wxRect___ne__(arg1,arg2);
7400 if (PyErr_Occurred()) SWIG_fail;
7401 }
7402 {
7403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7404 }
7405 return resultobj;
7406 fail:
7407 return NULL;
7408 }
7409
7410
7411 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7412 PyObject *resultobj = 0;
7413 wxRect *arg1 = (wxRect *) 0 ;
7414 int arg2 ;
7415 int arg3 ;
7416 bool result;
7417 void *argp1 = 0 ;
7418 int res1 = 0 ;
7419 int val2 ;
7420 int ecode2 = 0 ;
7421 int val3 ;
7422 int ecode3 = 0 ;
7423 PyObject * obj0 = 0 ;
7424 PyObject * obj1 = 0 ;
7425 PyObject * obj2 = 0 ;
7426 char * kwnames[] = {
7427 (char *) "self",(char *) "x",(char *) "y", NULL
7428 };
7429
7430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7432 if (!SWIG_IsOK(res1)) {
7433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7434 }
7435 arg1 = reinterpret_cast< wxRect * >(argp1);
7436 ecode2 = SWIG_AsVal_int(obj1, &val2);
7437 if (!SWIG_IsOK(ecode2)) {
7438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7439 }
7440 arg2 = static_cast< int >(val2);
7441 ecode3 = SWIG_AsVal_int(obj2, &val3);
7442 if (!SWIG_IsOK(ecode3)) {
7443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7444 }
7445 arg3 = static_cast< int >(val3);
7446 {
7447 PyThreadState* __tstate = wxPyBeginAllowThreads();
7448 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7449 wxPyEndAllowThreads(__tstate);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 {
7453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7454 }
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj = 0;
7463 wxRect *arg1 = (wxRect *) 0 ;
7464 wxPoint *arg2 = 0 ;
7465 bool result;
7466 void *argp1 = 0 ;
7467 int res1 = 0 ;
7468 wxPoint temp2 ;
7469 PyObject * obj0 = 0 ;
7470 PyObject * obj1 = 0 ;
7471 char * kwnames[] = {
7472 (char *) "self",(char *) "pt", NULL
7473 };
7474
7475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7477 if (!SWIG_IsOK(res1)) {
7478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7479 }
7480 arg1 = reinterpret_cast< wxRect * >(argp1);
7481 {
7482 arg2 = &temp2;
7483 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7484 }
7485 {
7486 PyThreadState* __tstate = wxPyBeginAllowThreads();
7487 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7488 wxPyEndAllowThreads(__tstate);
7489 if (PyErr_Occurred()) SWIG_fail;
7490 }
7491 {
7492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7493 }
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7501 PyObject *resultobj = 0;
7502 wxRect *arg1 = (wxRect *) 0 ;
7503 wxRect *arg2 = 0 ;
7504 bool result;
7505 void *argp1 = 0 ;
7506 int res1 = 0 ;
7507 wxRect temp2 ;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 char * kwnames[] = {
7511 (char *) "self",(char *) "rect", NULL
7512 };
7513
7514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7518 }
7519 arg1 = reinterpret_cast< wxRect * >(argp1);
7520 {
7521 arg2 = &temp2;
7522 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7523 }
7524 {
7525 PyThreadState* __tstate = wxPyBeginAllowThreads();
7526 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 {
7531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7532 }
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7540 PyObject *resultobj = 0;
7541 wxRect *arg1 = (wxRect *) 0 ;
7542 wxRect *arg2 = 0 ;
7543 int arg3 = (int) wxBOTH ;
7544 wxRect result;
7545 void *argp1 = 0 ;
7546 int res1 = 0 ;
7547 wxRect temp2 ;
7548 int val3 ;
7549 int ecode3 = 0 ;
7550 PyObject * obj0 = 0 ;
7551 PyObject * obj1 = 0 ;
7552 PyObject * obj2 = 0 ;
7553 char * kwnames[] = {
7554 (char *) "self",(char *) "r",(char *) "dir", NULL
7555 };
7556
7557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7561 }
7562 arg1 = reinterpret_cast< wxRect * >(argp1);
7563 {
7564 arg2 = &temp2;
7565 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7566 }
7567 if (obj2) {
7568 ecode3 = SWIG_AsVal_int(obj2, &val3);
7569 if (!SWIG_IsOK(ecode3)) {
7570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7571 }
7572 arg3 = static_cast< int >(val3);
7573 }
7574 {
7575 PyThreadState* __tstate = wxPyBeginAllowThreads();
7576 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7577 wxPyEndAllowThreads(__tstate);
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7588 PyObject *resultobj = 0;
7589 wxRect *arg1 = (wxRect *) 0 ;
7590 int arg2 ;
7591 void *argp1 = 0 ;
7592 int res1 = 0 ;
7593 int val2 ;
7594 int ecode2 = 0 ;
7595 PyObject *swig_obj[2] ;
7596
7597 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7601 }
7602 arg1 = reinterpret_cast< wxRect * >(argp1);
7603 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7604 if (!SWIG_IsOK(ecode2)) {
7605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7606 }
7607 arg2 = static_cast< int >(val2);
7608 if (arg1) (arg1)->x = arg2;
7609
7610 resultobj = SWIG_Py_Void();
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7618 PyObject *resultobj = 0;
7619 wxRect *arg1 = (wxRect *) 0 ;
7620 int result;
7621 void *argp1 = 0 ;
7622 int res1 = 0 ;
7623 PyObject *swig_obj[1] ;
7624
7625 if (!args) SWIG_fail;
7626 swig_obj[0] = args;
7627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7628 if (!SWIG_IsOK(res1)) {
7629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7630 }
7631 arg1 = reinterpret_cast< wxRect * >(argp1);
7632 result = (int) ((arg1)->x);
7633 resultobj = SWIG_From_int(static_cast< int >(result));
7634 return resultobj;
7635 fail:
7636 return NULL;
7637 }
7638
7639
7640 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7641 PyObject *resultobj = 0;
7642 wxRect *arg1 = (wxRect *) 0 ;
7643 int arg2 ;
7644 void *argp1 = 0 ;
7645 int res1 = 0 ;
7646 int val2 ;
7647 int ecode2 = 0 ;
7648 PyObject *swig_obj[2] ;
7649
7650 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7652 if (!SWIG_IsOK(res1)) {
7653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7654 }
7655 arg1 = reinterpret_cast< wxRect * >(argp1);
7656 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7657 if (!SWIG_IsOK(ecode2)) {
7658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7659 }
7660 arg2 = static_cast< int >(val2);
7661 if (arg1) (arg1)->y = arg2;
7662
7663 resultobj = SWIG_Py_Void();
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7671 PyObject *resultobj = 0;
7672 wxRect *arg1 = (wxRect *) 0 ;
7673 int result;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 PyObject *swig_obj[1] ;
7677
7678 if (!args) SWIG_fail;
7679 swig_obj[0] = args;
7680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7681 if (!SWIG_IsOK(res1)) {
7682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7683 }
7684 arg1 = reinterpret_cast< wxRect * >(argp1);
7685 result = (int) ((arg1)->y);
7686 resultobj = SWIG_From_int(static_cast< int >(result));
7687 return resultobj;
7688 fail:
7689 return NULL;
7690 }
7691
7692
7693 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7694 PyObject *resultobj = 0;
7695 wxRect *arg1 = (wxRect *) 0 ;
7696 int arg2 ;
7697 void *argp1 = 0 ;
7698 int res1 = 0 ;
7699 int val2 ;
7700 int ecode2 = 0 ;
7701 PyObject *swig_obj[2] ;
7702
7703 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7705 if (!SWIG_IsOK(res1)) {
7706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7707 }
7708 arg1 = reinterpret_cast< wxRect * >(argp1);
7709 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7710 if (!SWIG_IsOK(ecode2)) {
7711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7712 }
7713 arg2 = static_cast< int >(val2);
7714 if (arg1) (arg1)->width = arg2;
7715
7716 resultobj = SWIG_Py_Void();
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7724 PyObject *resultobj = 0;
7725 wxRect *arg1 = (wxRect *) 0 ;
7726 int result;
7727 void *argp1 = 0 ;
7728 int res1 = 0 ;
7729 PyObject *swig_obj[1] ;
7730
7731 if (!args) SWIG_fail;
7732 swig_obj[0] = args;
7733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7734 if (!SWIG_IsOK(res1)) {
7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7736 }
7737 arg1 = reinterpret_cast< wxRect * >(argp1);
7738 result = (int) ((arg1)->width);
7739 resultobj = SWIG_From_int(static_cast< int >(result));
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7747 PyObject *resultobj = 0;
7748 wxRect *arg1 = (wxRect *) 0 ;
7749 int arg2 ;
7750 void *argp1 = 0 ;
7751 int res1 = 0 ;
7752 int val2 ;
7753 int ecode2 = 0 ;
7754 PyObject *swig_obj[2] ;
7755
7756 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7760 }
7761 arg1 = reinterpret_cast< wxRect * >(argp1);
7762 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7763 if (!SWIG_IsOK(ecode2)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7765 }
7766 arg2 = static_cast< int >(val2);
7767 if (arg1) (arg1)->height = arg2;
7768
7769 resultobj = SWIG_Py_Void();
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7777 PyObject *resultobj = 0;
7778 wxRect *arg1 = (wxRect *) 0 ;
7779 int result;
7780 void *argp1 = 0 ;
7781 int res1 = 0 ;
7782 PyObject *swig_obj[1] ;
7783
7784 if (!args) SWIG_fail;
7785 swig_obj[0] = args;
7786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7787 if (!SWIG_IsOK(res1)) {
7788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7789 }
7790 arg1 = reinterpret_cast< wxRect * >(argp1);
7791 result = (int) ((arg1)->height);
7792 resultobj = SWIG_From_int(static_cast< int >(result));
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7800 PyObject *resultobj = 0;
7801 wxRect *arg1 = (wxRect *) 0 ;
7802 int arg2 = (int) 0 ;
7803 int arg3 = (int) 0 ;
7804 int arg4 = (int) 0 ;
7805 int arg5 = (int) 0 ;
7806 void *argp1 = 0 ;
7807 int res1 = 0 ;
7808 int val2 ;
7809 int ecode2 = 0 ;
7810 int val3 ;
7811 int ecode3 = 0 ;
7812 int val4 ;
7813 int ecode4 = 0 ;
7814 int val5 ;
7815 int ecode5 = 0 ;
7816 PyObject * obj0 = 0 ;
7817 PyObject * obj1 = 0 ;
7818 PyObject * obj2 = 0 ;
7819 PyObject * obj3 = 0 ;
7820 PyObject * obj4 = 0 ;
7821 char * kwnames[] = {
7822 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7823 };
7824
7825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7829 }
7830 arg1 = reinterpret_cast< wxRect * >(argp1);
7831 if (obj1) {
7832 ecode2 = SWIG_AsVal_int(obj1, &val2);
7833 if (!SWIG_IsOK(ecode2)) {
7834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7835 }
7836 arg2 = static_cast< int >(val2);
7837 }
7838 if (obj2) {
7839 ecode3 = SWIG_AsVal_int(obj2, &val3);
7840 if (!SWIG_IsOK(ecode3)) {
7841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7842 }
7843 arg3 = static_cast< int >(val3);
7844 }
7845 if (obj3) {
7846 ecode4 = SWIG_AsVal_int(obj3, &val4);
7847 if (!SWIG_IsOK(ecode4)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7849 }
7850 arg4 = static_cast< int >(val4);
7851 }
7852 if (obj4) {
7853 ecode5 = SWIG_AsVal_int(obj4, &val5);
7854 if (!SWIG_IsOK(ecode5)) {
7855 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7856 }
7857 arg5 = static_cast< int >(val5);
7858 }
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7862 wxPyEndAllowThreads(__tstate);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 resultobj = SWIG_Py_Void();
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7873 PyObject *resultobj = 0;
7874 wxRect *arg1 = (wxRect *) 0 ;
7875 PyObject *result = 0 ;
7876 void *argp1 = 0 ;
7877 int res1 = 0 ;
7878 PyObject *swig_obj[1] ;
7879
7880 if (!args) SWIG_fail;
7881 swig_obj[0] = args;
7882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7883 if (!SWIG_IsOK(res1)) {
7884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7885 }
7886 arg1 = reinterpret_cast< wxRect * >(argp1);
7887 {
7888 PyThreadState* __tstate = wxPyBeginAllowThreads();
7889 result = (PyObject *)wxRect_Get(arg1);
7890 wxPyEndAllowThreads(__tstate);
7891 if (PyErr_Occurred()) SWIG_fail;
7892 }
7893 resultobj = result;
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7901 PyObject *obj;
7902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7903 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7904 return SWIG_Py_Void();
7905 }
7906
7907 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7908 return SWIG_Python_InitShadowInstance(args);
7909 }
7910
7911 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7912 PyObject *resultobj = 0;
7913 wxRect *arg1 = (wxRect *) 0 ;
7914 wxRect *arg2 = (wxRect *) 0 ;
7915 PyObject *result = 0 ;
7916 void *argp1 = 0 ;
7917 int res1 = 0 ;
7918 void *argp2 = 0 ;
7919 int res2 = 0 ;
7920 PyObject * obj0 = 0 ;
7921 PyObject * obj1 = 0 ;
7922 char * kwnames[] = {
7923 (char *) "r1",(char *) "r2", NULL
7924 };
7925
7926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7928 if (!SWIG_IsOK(res1)) {
7929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7930 }
7931 arg1 = reinterpret_cast< wxRect * >(argp1);
7932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7933 if (!SWIG_IsOK(res2)) {
7934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7935 }
7936 arg2 = reinterpret_cast< wxRect * >(argp2);
7937 {
7938 if (!wxPyCheckForApp()) SWIG_fail;
7939 PyThreadState* __tstate = wxPyBeginAllowThreads();
7940 result = (PyObject *)wxIntersectRect(arg1,arg2);
7941 wxPyEndAllowThreads(__tstate);
7942 if (PyErr_Occurred()) SWIG_fail;
7943 }
7944 resultobj = result;
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7952 PyObject *resultobj = 0;
7953 double arg1 = (double) 0.0 ;
7954 double arg2 = (double) 0.0 ;
7955 wxPoint2D *result = 0 ;
7956 double val1 ;
7957 int ecode1 = 0 ;
7958 double val2 ;
7959 int ecode2 = 0 ;
7960 PyObject * obj0 = 0 ;
7961 PyObject * obj1 = 0 ;
7962 char * kwnames[] = {
7963 (char *) "x",(char *) "y", NULL
7964 };
7965
7966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7967 if (obj0) {
7968 ecode1 = SWIG_AsVal_double(obj0, &val1);
7969 if (!SWIG_IsOK(ecode1)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7971 }
7972 arg1 = static_cast< double >(val1);
7973 }
7974 if (obj1) {
7975 ecode2 = SWIG_AsVal_double(obj1, &val2);
7976 if (!SWIG_IsOK(ecode2)) {
7977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7978 }
7979 arg2 = static_cast< double >(val2);
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7995 PyObject *resultobj = 0;
7996 wxPoint2D *arg1 = 0 ;
7997 wxPoint2D *result = 0 ;
7998 wxPoint2D temp1 ;
7999 PyObject * obj0 = 0 ;
8000 char * kwnames[] = {
8001 (char *) "pt", NULL
8002 };
8003
8004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8005 {
8006 arg1 = &temp1;
8007 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8008 }
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8023 PyObject *resultobj = 0;
8024 wxPoint *arg1 = 0 ;
8025 wxPoint2D *result = 0 ;
8026 wxPoint temp1 ;
8027 PyObject * obj0 = 0 ;
8028 char * kwnames[] = {
8029 (char *) "pt", NULL
8030 };
8031
8032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8033 {
8034 arg1 = &temp1;
8035 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8036 }
8037 {
8038 PyThreadState* __tstate = wxPyBeginAllowThreads();
8039 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8040 wxPyEndAllowThreads(__tstate);
8041 if (PyErr_Occurred()) SWIG_fail;
8042 }
8043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8051 PyObject *resultobj = 0;
8052 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8053 int *arg2 = (int *) 0 ;
8054 int *arg3 = (int *) 0 ;
8055 void *argp1 = 0 ;
8056 int res1 = 0 ;
8057 int temp2 ;
8058 int res2 = SWIG_TMPOBJ ;
8059 int temp3 ;
8060 int res3 = SWIG_TMPOBJ ;
8061 PyObject *swig_obj[1] ;
8062
8063 arg2 = &temp2;
8064 arg3 = &temp3;
8065 if (!args) SWIG_fail;
8066 swig_obj[0] = args;
8067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8068 if (!SWIG_IsOK(res1)) {
8069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8070 }
8071 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8075 wxPyEndAllowThreads(__tstate);
8076 if (PyErr_Occurred()) SWIG_fail;
8077 }
8078 resultobj = SWIG_Py_Void();
8079 if (SWIG_IsTmpObj(res2)) {
8080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8081 } else {
8082 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8084 }
8085 if (SWIG_IsTmpObj(res3)) {
8086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8087 } else {
8088 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8090 }
8091 return resultobj;
8092 fail:
8093 return NULL;
8094 }
8095
8096
8097 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8098 PyObject *resultobj = 0;
8099 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8100 int *arg2 = (int *) 0 ;
8101 int *arg3 = (int *) 0 ;
8102 void *argp1 = 0 ;
8103 int res1 = 0 ;
8104 int temp2 ;
8105 int res2 = SWIG_TMPOBJ ;
8106 int temp3 ;
8107 int res3 = SWIG_TMPOBJ ;
8108 PyObject *swig_obj[1] ;
8109
8110 arg2 = &temp2;
8111 arg3 = &temp3;
8112 if (!args) SWIG_fail;
8113 swig_obj[0] = args;
8114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8115 if (!SWIG_IsOK(res1)) {
8116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8117 }
8118 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8119 {
8120 PyThreadState* __tstate = wxPyBeginAllowThreads();
8121 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8122 wxPyEndAllowThreads(__tstate);
8123 if (PyErr_Occurred()) SWIG_fail;
8124 }
8125 resultobj = SWIG_Py_Void();
8126 if (SWIG_IsTmpObj(res2)) {
8127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8128 } else {
8129 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8131 }
8132 if (SWIG_IsTmpObj(res3)) {
8133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8134 } else {
8135 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8137 }
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8145 PyObject *resultobj = 0;
8146 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8147 double result;
8148 void *argp1 = 0 ;
8149 int res1 = 0 ;
8150 PyObject *swig_obj[1] ;
8151
8152 if (!args) SWIG_fail;
8153 swig_obj[0] = args;
8154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8155 if (!SWIG_IsOK(res1)) {
8156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8157 }
8158 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = SWIG_From_double(static_cast< double >(result));
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *resultobj = 0;
8174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8175 double result;
8176 void *argp1 = 0 ;
8177 int res1 = 0 ;
8178 PyObject *swig_obj[1] ;
8179
8180 if (!args) SWIG_fail;
8181 swig_obj[0] = args;
8182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8183 if (!SWIG_IsOK(res1)) {
8184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8185 }
8186 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8187 {
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_From_double(static_cast< double >(result));
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj = 0;
8202 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8203 double arg2 ;
8204 void *argp1 = 0 ;
8205 int res1 = 0 ;
8206 double val2 ;
8207 int ecode2 = 0 ;
8208 PyObject * obj0 = 0 ;
8209 PyObject * obj1 = 0 ;
8210 char * kwnames[] = {
8211 (char *) "self",(char *) "length", NULL
8212 };
8213
8214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8216 if (!SWIG_IsOK(res1)) {
8217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8218 }
8219 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8220 ecode2 = SWIG_AsVal_double(obj1, &val2);
8221 if (!SWIG_IsOK(ecode2)) {
8222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8223 }
8224 arg2 = static_cast< double >(val2);
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 (arg1)->SetVectorLength(arg2);
8228 wxPyEndAllowThreads(__tstate);
8229 if (PyErr_Occurred()) SWIG_fail;
8230 }
8231 resultobj = SWIG_Py_Void();
8232 return resultobj;
8233 fail:
8234 return NULL;
8235 }
8236
8237
8238 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8239 PyObject *resultobj = 0;
8240 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8241 double arg2 ;
8242 void *argp1 = 0 ;
8243 int res1 = 0 ;
8244 double val2 ;
8245 int ecode2 = 0 ;
8246 PyObject * obj0 = 0 ;
8247 PyObject * obj1 = 0 ;
8248 char * kwnames[] = {
8249 (char *) "self",(char *) "degrees", NULL
8250 };
8251
8252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8254 if (!SWIG_IsOK(res1)) {
8255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8256 }
8257 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8258 ecode2 = SWIG_AsVal_double(obj1, &val2);
8259 if (!SWIG_IsOK(ecode2)) {
8260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8261 }
8262 arg2 = static_cast< double >(val2);
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 (arg1)->SetVectorAngle(arg2);
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 resultobj = SWIG_Py_Void();
8270 return resultobj;
8271 fail:
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8277 PyObject *resultobj = 0;
8278 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8279 wxPoint2D *arg2 = 0 ;
8280 double result;
8281 void *argp1 = 0 ;
8282 int res1 = 0 ;
8283 wxPoint2D temp2 ;
8284 PyObject * obj0 = 0 ;
8285 PyObject * obj1 = 0 ;
8286 char * kwnames[] = {
8287 (char *) "self",(char *) "pt", NULL
8288 };
8289
8290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8292 if (!SWIG_IsOK(res1)) {
8293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8294 }
8295 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8296 {
8297 arg2 = &temp2;
8298 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8299 }
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8303 wxPyEndAllowThreads(__tstate);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 resultobj = SWIG_From_double(static_cast< double >(result));
8307 return resultobj;
8308 fail:
8309 return NULL;
8310 }
8311
8312
8313 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8314 PyObject *resultobj = 0;
8315 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8316 wxPoint2D *arg2 = 0 ;
8317 double result;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 wxPoint2D temp2 ;
8321 PyObject * obj0 = 0 ;
8322 PyObject * obj1 = 0 ;
8323 char * kwnames[] = {
8324 (char *) "self",(char *) "pt", NULL
8325 };
8326
8327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8329 if (!SWIG_IsOK(res1)) {
8330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8331 }
8332 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8333 {
8334 arg2 = &temp2;
8335 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 resultobj = SWIG_From_double(static_cast< double >(result));
8344 return resultobj;
8345 fail:
8346 return NULL;
8347 }
8348
8349
8350 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8351 PyObject *resultobj = 0;
8352 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8353 wxPoint2D *arg2 = 0 ;
8354 double result;
8355 void *argp1 = 0 ;
8356 int res1 = 0 ;
8357 wxPoint2D temp2 ;
8358 PyObject * obj0 = 0 ;
8359 PyObject * obj1 = 0 ;
8360 char * kwnames[] = {
8361 (char *) "self",(char *) "vec", NULL
8362 };
8363
8364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8366 if (!SWIG_IsOK(res1)) {
8367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8368 }
8369 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8370 {
8371 arg2 = &temp2;
8372 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8373 }
8374 {
8375 PyThreadState* __tstate = wxPyBeginAllowThreads();
8376 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8377 wxPyEndAllowThreads(__tstate);
8378 if (PyErr_Occurred()) SWIG_fail;
8379 }
8380 resultobj = SWIG_From_double(static_cast< double >(result));
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8388 PyObject *resultobj = 0;
8389 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8390 wxPoint2D *arg2 = 0 ;
8391 double result;
8392 void *argp1 = 0 ;
8393 int res1 = 0 ;
8394 wxPoint2D temp2 ;
8395 PyObject * obj0 = 0 ;
8396 PyObject * obj1 = 0 ;
8397 char * kwnames[] = {
8398 (char *) "self",(char *) "vec", NULL
8399 };
8400
8401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8403 if (!SWIG_IsOK(res1)) {
8404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8405 }
8406 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8407 {
8408 arg2 = &temp2;
8409 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8410 }
8411 {
8412 PyThreadState* __tstate = wxPyBeginAllowThreads();
8413 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 resultobj = SWIG_From_double(static_cast< double >(result));
8418 return resultobj;
8419 fail:
8420 return NULL;
8421 }
8422
8423
8424 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8425 PyObject *resultobj = 0;
8426 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8427 wxPoint2D result;
8428 void *argp1 = 0 ;
8429 int res1 = 0 ;
8430 PyObject *swig_obj[1] ;
8431
8432 if (!args) SWIG_fail;
8433 swig_obj[0] = args;
8434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8435 if (!SWIG_IsOK(res1)) {
8436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8437 }
8438 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8439 {
8440 PyThreadState* __tstate = wxPyBeginAllowThreads();
8441 result = (arg1)->operator -();
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8446 return resultobj;
8447 fail:
8448 return NULL;
8449 }
8450
8451
8452 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8453 PyObject *resultobj = 0;
8454 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8455 wxPoint2D *arg2 = 0 ;
8456 wxPoint2D *result = 0 ;
8457 void *argp1 = 0 ;
8458 int res1 = 0 ;
8459 wxPoint2D temp2 ;
8460 PyObject * obj0 = 0 ;
8461 PyObject * obj1 = 0 ;
8462 char * kwnames[] = {
8463 (char *) "self",(char *) "pt", NULL
8464 };
8465
8466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8468 if (!SWIG_IsOK(res1)) {
8469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8470 }
8471 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8472 {
8473 arg2 = &temp2;
8474 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8475 }
8476 {
8477 PyThreadState* __tstate = wxPyBeginAllowThreads();
8478 {
8479 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8480 result = (wxPoint2D *) &_result_ref;
8481 }
8482 wxPyEndAllowThreads(__tstate);
8483 if (PyErr_Occurred()) SWIG_fail;
8484 }
8485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8486 return resultobj;
8487 fail:
8488 return NULL;
8489 }
8490
8491
8492 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8493 PyObject *resultobj = 0;
8494 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8495 wxPoint2D *arg2 = 0 ;
8496 wxPoint2D *result = 0 ;
8497 void *argp1 = 0 ;
8498 int res1 = 0 ;
8499 wxPoint2D temp2 ;
8500 PyObject * obj0 = 0 ;
8501 PyObject * obj1 = 0 ;
8502 char * kwnames[] = {
8503 (char *) "self",(char *) "pt", NULL
8504 };
8505
8506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8508 if (!SWIG_IsOK(res1)) {
8509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8510 }
8511 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8512 {
8513 arg2 = &temp2;
8514 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8515 }
8516 {
8517 PyThreadState* __tstate = wxPyBeginAllowThreads();
8518 {
8519 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8520 result = (wxPoint2D *) &_result_ref;
8521 }
8522 wxPyEndAllowThreads(__tstate);
8523 if (PyErr_Occurred()) SWIG_fail;
8524 }
8525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8526 return resultobj;
8527 fail:
8528 return NULL;
8529 }
8530
8531
8532 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8533 PyObject *resultobj = 0;
8534 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8535 wxPoint2D *arg2 = 0 ;
8536 wxPoint2D *result = 0 ;
8537 void *argp1 = 0 ;
8538 int res1 = 0 ;
8539 wxPoint2D temp2 ;
8540 PyObject * obj0 = 0 ;
8541 PyObject * obj1 = 0 ;
8542 char * kwnames[] = {
8543 (char *) "self",(char *) "pt", NULL
8544 };
8545
8546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8548 if (!SWIG_IsOK(res1)) {
8549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8550 }
8551 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8552 {
8553 arg2 = &temp2;
8554 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8555 }
8556 {
8557 PyThreadState* __tstate = wxPyBeginAllowThreads();
8558 {
8559 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8560 result = (wxPoint2D *) &_result_ref;
8561 }
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8566 return resultobj;
8567 fail:
8568 return NULL;
8569 }
8570
8571
8572 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8573 PyObject *resultobj = 0;
8574 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8575 wxPoint2D *arg2 = 0 ;
8576 wxPoint2D *result = 0 ;
8577 void *argp1 = 0 ;
8578 int res1 = 0 ;
8579 wxPoint2D temp2 ;
8580 PyObject * obj0 = 0 ;
8581 PyObject * obj1 = 0 ;
8582 char * kwnames[] = {
8583 (char *) "self",(char *) "pt", NULL
8584 };
8585
8586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8588 if (!SWIG_IsOK(res1)) {
8589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8590 }
8591 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8592 {
8593 arg2 = &temp2;
8594 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8595 }
8596 {
8597 PyThreadState* __tstate = wxPyBeginAllowThreads();
8598 {
8599 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8600 result = (wxPoint2D *) &_result_ref;
8601 }
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8606 return resultobj;
8607 fail:
8608 return NULL;
8609 }
8610
8611
8612 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8613 PyObject *resultobj = 0;
8614 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8615 PyObject *arg2 = (PyObject *) 0 ;
8616 bool result;
8617 void *argp1 = 0 ;
8618 int res1 = 0 ;
8619 PyObject * obj0 = 0 ;
8620 PyObject * obj1 = 0 ;
8621 char * kwnames[] = {
8622 (char *) "self",(char *) "other", NULL
8623 };
8624
8625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8627 if (!SWIG_IsOK(res1)) {
8628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8629 }
8630 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8631 arg2 = obj1;
8632 {
8633 result = (bool)wxPoint2D___eq__(arg1,arg2);
8634 if (PyErr_Occurred()) SWIG_fail;
8635 }
8636 {
8637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8638 }
8639 return resultobj;
8640 fail:
8641 return NULL;
8642 }
8643
8644
8645 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8646 PyObject *resultobj = 0;
8647 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8648 PyObject *arg2 = (PyObject *) 0 ;
8649 bool result;
8650 void *argp1 = 0 ;
8651 int res1 = 0 ;
8652 PyObject * obj0 = 0 ;
8653 PyObject * obj1 = 0 ;
8654 char * kwnames[] = {
8655 (char *) "self",(char *) "other", NULL
8656 };
8657
8658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8660 if (!SWIG_IsOK(res1)) {
8661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8662 }
8663 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8664 arg2 = obj1;
8665 {
8666 result = (bool)wxPoint2D___ne__(arg1,arg2);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 {
8670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8671 }
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8679 PyObject *resultobj = 0;
8680 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8681 double arg2 ;
8682 void *argp1 = 0 ;
8683 int res1 = 0 ;
8684 double val2 ;
8685 int ecode2 = 0 ;
8686 PyObject *swig_obj[2] ;
8687
8688 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8690 if (!SWIG_IsOK(res1)) {
8691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8692 }
8693 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8694 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8695 if (!SWIG_IsOK(ecode2)) {
8696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8697 }
8698 arg2 = static_cast< double >(val2);
8699 if (arg1) (arg1)->m_x = arg2;
8700
8701 resultobj = SWIG_Py_Void();
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8709 PyObject *resultobj = 0;
8710 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8711 double result;
8712 void *argp1 = 0 ;
8713 int res1 = 0 ;
8714 PyObject *swig_obj[1] ;
8715
8716 if (!args) SWIG_fail;
8717 swig_obj[0] = args;
8718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8719 if (!SWIG_IsOK(res1)) {
8720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8721 }
8722 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8723 result = (double) ((arg1)->m_x);
8724 resultobj = SWIG_From_double(static_cast< double >(result));
8725 return resultobj;
8726 fail:
8727 return NULL;
8728 }
8729
8730
8731 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8732 PyObject *resultobj = 0;
8733 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8734 double arg2 ;
8735 void *argp1 = 0 ;
8736 int res1 = 0 ;
8737 double val2 ;
8738 int ecode2 = 0 ;
8739 PyObject *swig_obj[2] ;
8740
8741 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8743 if (!SWIG_IsOK(res1)) {
8744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8745 }
8746 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8747 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8748 if (!SWIG_IsOK(ecode2)) {
8749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8750 }
8751 arg2 = static_cast< double >(val2);
8752 if (arg1) (arg1)->m_y = arg2;
8753
8754 resultobj = SWIG_Py_Void();
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8762 PyObject *resultobj = 0;
8763 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8764 double result;
8765 void *argp1 = 0 ;
8766 int res1 = 0 ;
8767 PyObject *swig_obj[1] ;
8768
8769 if (!args) SWIG_fail;
8770 swig_obj[0] = args;
8771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8772 if (!SWIG_IsOK(res1)) {
8773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8774 }
8775 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8776 result = (double) ((arg1)->m_y);
8777 resultobj = SWIG_From_double(static_cast< double >(result));
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8785 PyObject *resultobj = 0;
8786 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8787 double arg2 = (double) 0 ;
8788 double arg3 = (double) 0 ;
8789 void *argp1 = 0 ;
8790 int res1 = 0 ;
8791 double val2 ;
8792 int ecode2 = 0 ;
8793 double val3 ;
8794 int ecode3 = 0 ;
8795 PyObject * obj0 = 0 ;
8796 PyObject * obj1 = 0 ;
8797 PyObject * obj2 = 0 ;
8798 char * kwnames[] = {
8799 (char *) "self",(char *) "x",(char *) "y", NULL
8800 };
8801
8802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8804 if (!SWIG_IsOK(res1)) {
8805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8806 }
8807 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8808 if (obj1) {
8809 ecode2 = SWIG_AsVal_double(obj1, &val2);
8810 if (!SWIG_IsOK(ecode2)) {
8811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8812 }
8813 arg2 = static_cast< double >(val2);
8814 }
8815 if (obj2) {
8816 ecode3 = SWIG_AsVal_double(obj2, &val3);
8817 if (!SWIG_IsOK(ecode3)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8819 }
8820 arg3 = static_cast< double >(val3);
8821 }
8822 {
8823 PyThreadState* __tstate = wxPyBeginAllowThreads();
8824 wxPoint2D_Set(arg1,arg2,arg3);
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 resultobj = SWIG_Py_Void();
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8836 PyObject *resultobj = 0;
8837 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8838 PyObject *result = 0 ;
8839 void *argp1 = 0 ;
8840 int res1 = 0 ;
8841 PyObject *swig_obj[1] ;
8842
8843 if (!args) SWIG_fail;
8844 swig_obj[0] = args;
8845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8846 if (!SWIG_IsOK(res1)) {
8847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8848 }
8849 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8850 {
8851 PyThreadState* __tstate = wxPyBeginAllowThreads();
8852 result = (PyObject *)wxPoint2D_Get(arg1);
8853 wxPyEndAllowThreads(__tstate);
8854 if (PyErr_Occurred()) SWIG_fail;
8855 }
8856 resultobj = result;
8857 return resultobj;
8858 fail:
8859 return NULL;
8860 }
8861
8862
8863 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8864 PyObject *obj;
8865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8866 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8867 return SWIG_Py_Void();
8868 }
8869
8870 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8871 return SWIG_Python_InitShadowInstance(args);
8872 }
8873
8874 SWIGINTERN int DefaultPosition_set(PyObject *) {
8875 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8876 return 1;
8877 }
8878
8879
8880 SWIGINTERN PyObject *DefaultPosition_get(void) {
8881 PyObject *pyobj = 0;
8882
8883 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8884 return pyobj;
8885 }
8886
8887
8888 SWIGINTERN int DefaultSize_set(PyObject *) {
8889 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8890 return 1;
8891 }
8892
8893
8894 SWIGINTERN PyObject *DefaultSize_get(void) {
8895 PyObject *pyobj = 0;
8896
8897 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8898 return pyobj;
8899 }
8900
8901
8902 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8903 PyObject *resultobj = 0;
8904 PyObject *arg1 = (PyObject *) 0 ;
8905 wxPyInputStream *result = 0 ;
8906 PyObject * obj0 = 0 ;
8907 char * kwnames[] = {
8908 (char *) "p", NULL
8909 };
8910
8911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8912 arg1 = obj0;
8913 {
8914 PyThreadState* __tstate = wxPyBeginAllowThreads();
8915 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
8926 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8927 PyObject *resultobj = 0;
8928 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8929 void *argp1 = 0 ;
8930 int res1 = 0 ;
8931 PyObject *swig_obj[1] ;
8932
8933 if (!args) SWIG_fail;
8934 swig_obj[0] = args;
8935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8938 }
8939 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8940 {
8941 PyThreadState* __tstate = wxPyBeginAllowThreads();
8942 delete arg1;
8943
8944 wxPyEndAllowThreads(__tstate);
8945 if (PyErr_Occurred()) SWIG_fail;
8946 }
8947 resultobj = SWIG_Py_Void();
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8955 PyObject *resultobj = 0;
8956 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8957 void *argp1 = 0 ;
8958 int res1 = 0 ;
8959 PyObject *swig_obj[1] ;
8960
8961 if (!args) SWIG_fail;
8962 swig_obj[0] = args;
8963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8964 if (!SWIG_IsOK(res1)) {
8965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8966 }
8967 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8968 {
8969 PyThreadState* __tstate = wxPyBeginAllowThreads();
8970 (arg1)->close();
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 resultobj = SWIG_Py_Void();
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8982 PyObject *resultobj = 0;
8983 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8984 void *argp1 = 0 ;
8985 int res1 = 0 ;
8986 PyObject *swig_obj[1] ;
8987
8988 if (!args) SWIG_fail;
8989 swig_obj[0] = args;
8990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8991 if (!SWIG_IsOK(res1)) {
8992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8993 }
8994 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8995 {
8996 PyThreadState* __tstate = wxPyBeginAllowThreads();
8997 (arg1)->flush();
8998 wxPyEndAllowThreads(__tstate);
8999 if (PyErr_Occurred()) SWIG_fail;
9000 }
9001 resultobj = SWIG_Py_Void();
9002 return resultobj;
9003 fail:
9004 return NULL;
9005 }
9006
9007
9008 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9009 PyObject *resultobj = 0;
9010 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9011 bool result;
9012 void *argp1 = 0 ;
9013 int res1 = 0 ;
9014 PyObject *swig_obj[1] ;
9015
9016 if (!args) SWIG_fail;
9017 swig_obj[0] = args;
9018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9019 if (!SWIG_IsOK(res1)) {
9020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9021 }
9022 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 result = (bool)(arg1)->eof();
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 {
9030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9031 }
9032 return resultobj;
9033 fail:
9034 return NULL;
9035 }
9036
9037
9038 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9039 PyObject *resultobj = 0;
9040 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9041 int arg2 = (int) -1 ;
9042 PyObject *result = 0 ;
9043 void *argp1 = 0 ;
9044 int res1 = 0 ;
9045 int val2 ;
9046 int ecode2 = 0 ;
9047 PyObject * obj0 = 0 ;
9048 PyObject * obj1 = 0 ;
9049 char * kwnames[] = {
9050 (char *) "self",(char *) "size", NULL
9051 };
9052
9053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9055 if (!SWIG_IsOK(res1)) {
9056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9057 }
9058 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9059 if (obj1) {
9060 ecode2 = SWIG_AsVal_int(obj1, &val2);
9061 if (!SWIG_IsOK(ecode2)) {
9062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9063 }
9064 arg2 = static_cast< int >(val2);
9065 }
9066 {
9067 PyThreadState* __tstate = wxPyBeginAllowThreads();
9068 result = (PyObject *)(arg1)->read(arg2);
9069 wxPyEndAllowThreads(__tstate);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 resultobj = result;
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9080 PyObject *resultobj = 0;
9081 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9082 int arg2 = (int) -1 ;
9083 PyObject *result = 0 ;
9084 void *argp1 = 0 ;
9085 int res1 = 0 ;
9086 int val2 ;
9087 int ecode2 = 0 ;
9088 PyObject * obj0 = 0 ;
9089 PyObject * obj1 = 0 ;
9090 char * kwnames[] = {
9091 (char *) "self",(char *) "size", NULL
9092 };
9093
9094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9096 if (!SWIG_IsOK(res1)) {
9097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9098 }
9099 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9100 if (obj1) {
9101 ecode2 = SWIG_AsVal_int(obj1, &val2);
9102 if (!SWIG_IsOK(ecode2)) {
9103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9104 }
9105 arg2 = static_cast< int >(val2);
9106 }
9107 {
9108 PyThreadState* __tstate = wxPyBeginAllowThreads();
9109 result = (PyObject *)(arg1)->readline(arg2);
9110 wxPyEndAllowThreads(__tstate);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 resultobj = result;
9114 return resultobj;
9115 fail:
9116 return NULL;
9117 }
9118
9119
9120 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9121 PyObject *resultobj = 0;
9122 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9123 int arg2 = (int) -1 ;
9124 PyObject *result = 0 ;
9125 void *argp1 = 0 ;
9126 int res1 = 0 ;
9127 int val2 ;
9128 int ecode2 = 0 ;
9129 PyObject * obj0 = 0 ;
9130 PyObject * obj1 = 0 ;
9131 char * kwnames[] = {
9132 (char *) "self",(char *) "sizehint", NULL
9133 };
9134
9135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9137 if (!SWIG_IsOK(res1)) {
9138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9139 }
9140 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9141 if (obj1) {
9142 ecode2 = SWIG_AsVal_int(obj1, &val2);
9143 if (!SWIG_IsOK(ecode2)) {
9144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9145 }
9146 arg2 = static_cast< int >(val2);
9147 }
9148 {
9149 PyThreadState* __tstate = wxPyBeginAllowThreads();
9150 result = (PyObject *)(arg1)->readlines(arg2);
9151 wxPyEndAllowThreads(__tstate);
9152 if (PyErr_Occurred()) SWIG_fail;
9153 }
9154 resultobj = result;
9155 return resultobj;
9156 fail:
9157 return NULL;
9158 }
9159
9160
9161 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9162 PyObject *resultobj = 0;
9163 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9164 int arg2 ;
9165 int arg3 = (int) 0 ;
9166 void *argp1 = 0 ;
9167 int res1 = 0 ;
9168 int val2 ;
9169 int ecode2 = 0 ;
9170 int val3 ;
9171 int ecode3 = 0 ;
9172 PyObject * obj0 = 0 ;
9173 PyObject * obj1 = 0 ;
9174 PyObject * obj2 = 0 ;
9175 char * kwnames[] = {
9176 (char *) "self",(char *) "offset",(char *) "whence", NULL
9177 };
9178
9179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9181 if (!SWIG_IsOK(res1)) {
9182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9183 }
9184 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9185 ecode2 = SWIG_AsVal_int(obj1, &val2);
9186 if (!SWIG_IsOK(ecode2)) {
9187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9188 }
9189 arg2 = static_cast< int >(val2);
9190 if (obj2) {
9191 ecode3 = SWIG_AsVal_int(obj2, &val3);
9192 if (!SWIG_IsOK(ecode3)) {
9193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9194 }
9195 arg3 = static_cast< int >(val3);
9196 }
9197 {
9198 PyThreadState* __tstate = wxPyBeginAllowThreads();
9199 (arg1)->seek(arg2,arg3);
9200 wxPyEndAllowThreads(__tstate);
9201 if (PyErr_Occurred()) SWIG_fail;
9202 }
9203 resultobj = SWIG_Py_Void();
9204 return resultobj;
9205 fail:
9206 return NULL;
9207 }
9208
9209
9210 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9211 PyObject *resultobj = 0;
9212 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9213 int result;
9214 void *argp1 = 0 ;
9215 int res1 = 0 ;
9216 PyObject *swig_obj[1] ;
9217
9218 if (!args) SWIG_fail;
9219 swig_obj[0] = args;
9220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9221 if (!SWIG_IsOK(res1)) {
9222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9223 }
9224 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9225 {
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 result = (int)(arg1)->tell();
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_From_int(static_cast< int >(result));
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9239 PyObject *resultobj = 0;
9240 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9241 char result;
9242 void *argp1 = 0 ;
9243 int res1 = 0 ;
9244 PyObject *swig_obj[1] ;
9245
9246 if (!args) SWIG_fail;
9247 swig_obj[0] = args;
9248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9249 if (!SWIG_IsOK(res1)) {
9250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9251 }
9252 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 result = (char)(arg1)->Peek();
9256 wxPyEndAllowThreads(__tstate);
9257 if (PyErr_Occurred()) SWIG_fail;
9258 }
9259 resultobj = SWIG_From_char(static_cast< char >(result));
9260 return resultobj;
9261 fail:
9262 return NULL;
9263 }
9264
9265
9266 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9267 PyObject *resultobj = 0;
9268 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9269 char result;
9270 void *argp1 = 0 ;
9271 int res1 = 0 ;
9272 PyObject *swig_obj[1] ;
9273
9274 if (!args) SWIG_fail;
9275 swig_obj[0] = args;
9276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9277 if (!SWIG_IsOK(res1)) {
9278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9279 }
9280 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9281 {
9282 PyThreadState* __tstate = wxPyBeginAllowThreads();
9283 result = (char)(arg1)->GetC();
9284 wxPyEndAllowThreads(__tstate);
9285 if (PyErr_Occurred()) SWIG_fail;
9286 }
9287 resultobj = SWIG_From_char(static_cast< char >(result));
9288 return resultobj;
9289 fail:
9290 return NULL;
9291 }
9292
9293
9294 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9295 PyObject *resultobj = 0;
9296 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9297 size_t result;
9298 void *argp1 = 0 ;
9299 int res1 = 0 ;
9300 PyObject *swig_obj[1] ;
9301
9302 if (!args) SWIG_fail;
9303 swig_obj[0] = args;
9304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9305 if (!SWIG_IsOK(res1)) {
9306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9307 }
9308 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 result = (size_t)(arg1)->LastRead();
9312 wxPyEndAllowThreads(__tstate);
9313 if (PyErr_Occurred()) SWIG_fail;
9314 }
9315 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9316 return resultobj;
9317 fail:
9318 return NULL;
9319 }
9320
9321
9322 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9323 PyObject *resultobj = 0;
9324 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9325 bool result;
9326 void *argp1 = 0 ;
9327 int res1 = 0 ;
9328 PyObject *swig_obj[1] ;
9329
9330 if (!args) SWIG_fail;
9331 swig_obj[0] = args;
9332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9333 if (!SWIG_IsOK(res1)) {
9334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9335 }
9336 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9337 {
9338 PyThreadState* __tstate = wxPyBeginAllowThreads();
9339 result = (bool)(arg1)->CanRead();
9340 wxPyEndAllowThreads(__tstate);
9341 if (PyErr_Occurred()) SWIG_fail;
9342 }
9343 {
9344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9345 }
9346 return resultobj;
9347 fail:
9348 return NULL;
9349 }
9350
9351
9352 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9353 PyObject *resultobj = 0;
9354 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9355 bool result;
9356 void *argp1 = 0 ;
9357 int res1 = 0 ;
9358 PyObject *swig_obj[1] ;
9359
9360 if (!args) SWIG_fail;
9361 swig_obj[0] = args;
9362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9363 if (!SWIG_IsOK(res1)) {
9364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9365 }
9366 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9367 {
9368 PyThreadState* __tstate = wxPyBeginAllowThreads();
9369 result = (bool)(arg1)->Eof();
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 {
9374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9375 }
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9383 PyObject *resultobj = 0;
9384 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9385 char arg2 ;
9386 bool result;
9387 void *argp1 = 0 ;
9388 int res1 = 0 ;
9389 char val2 ;
9390 int ecode2 = 0 ;
9391 PyObject * obj0 = 0 ;
9392 PyObject * obj1 = 0 ;
9393 char * kwnames[] = {
9394 (char *) "self",(char *) "c", NULL
9395 };
9396
9397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9399 if (!SWIG_IsOK(res1)) {
9400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9401 }
9402 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9403 ecode2 = SWIG_AsVal_char(obj1, &val2);
9404 if (!SWIG_IsOK(ecode2)) {
9405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9406 }
9407 arg2 = static_cast< char >(val2);
9408 {
9409 PyThreadState* __tstate = wxPyBeginAllowThreads();
9410 result = (bool)(arg1)->Ungetch(arg2);
9411 wxPyEndAllowThreads(__tstate);
9412 if (PyErr_Occurred()) SWIG_fail;
9413 }
9414 {
9415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9416 }
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9424 PyObject *resultobj = 0;
9425 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9426 long arg2 ;
9427 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9428 long result;
9429 void *argp1 = 0 ;
9430 int res1 = 0 ;
9431 long val2 ;
9432 int ecode2 = 0 ;
9433 int val3 ;
9434 int ecode3 = 0 ;
9435 PyObject * obj0 = 0 ;
9436 PyObject * obj1 = 0 ;
9437 PyObject * obj2 = 0 ;
9438 char * kwnames[] = {
9439 (char *) "self",(char *) "pos",(char *) "mode", NULL
9440 };
9441
9442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9444 if (!SWIG_IsOK(res1)) {
9445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9446 }
9447 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9448 ecode2 = SWIG_AsVal_long(obj1, &val2);
9449 if (!SWIG_IsOK(ecode2)) {
9450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9451 }
9452 arg2 = static_cast< long >(val2);
9453 if (obj2) {
9454 ecode3 = SWIG_AsVal_int(obj2, &val3);
9455 if (!SWIG_IsOK(ecode3)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9457 }
9458 arg3 = static_cast< wxSeekMode >(val3);
9459 }
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 result = (long)(arg1)->SeekI(arg2,arg3);
9463 wxPyEndAllowThreads(__tstate);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 resultobj = SWIG_From_long(static_cast< long >(result));
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9474 PyObject *resultobj = 0;
9475 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9476 long result;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 PyObject *swig_obj[1] ;
9480
9481 if (!args) SWIG_fail;
9482 swig_obj[0] = args;
9483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9484 if (!SWIG_IsOK(res1)) {
9485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9486 }
9487 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9488 {
9489 PyThreadState* __tstate = wxPyBeginAllowThreads();
9490 result = (long)(arg1)->TellI();
9491 wxPyEndAllowThreads(__tstate);
9492 if (PyErr_Occurred()) SWIG_fail;
9493 }
9494 resultobj = SWIG_From_long(static_cast< long >(result));
9495 return resultobj;
9496 fail:
9497 return NULL;
9498 }
9499
9500
9501 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9502 PyObject *obj;
9503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9504 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9505 return SWIG_Py_Void();
9506 }
9507
9508 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9509 return SWIG_Python_InitShadowInstance(args);
9510 }
9511
9512 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9513 PyObject *resultobj = 0;
9514 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9515 PyObject *arg2 = (PyObject *) 0 ;
9516 void *argp1 = 0 ;
9517 int res1 = 0 ;
9518 PyObject * obj0 = 0 ;
9519 PyObject * obj1 = 0 ;
9520 char * kwnames[] = {
9521 (char *) "self",(char *) "obj", NULL
9522 };
9523
9524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9526 if (!SWIG_IsOK(res1)) {
9527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9528 }
9529 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9530 arg2 = obj1;
9531 {
9532 PyThreadState* __tstate = wxPyBeginAllowThreads();
9533 wxOutputStream_write(arg1,arg2);
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 resultobj = SWIG_Py_Void();
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9545 PyObject *resultobj = 0;
9546 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9547 size_t result;
9548 void *argp1 = 0 ;
9549 int res1 = 0 ;
9550 PyObject *swig_obj[1] ;
9551
9552 if (!args) SWIG_fail;
9553 swig_obj[0] = args;
9554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9557 }
9558 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9559 {
9560 PyThreadState* __tstate = wxPyBeginAllowThreads();
9561 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9562 wxPyEndAllowThreads(__tstate);
9563 if (PyErr_Occurred()) SWIG_fail;
9564 }
9565 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9566 return resultobj;
9567 fail:
9568 return NULL;
9569 }
9570
9571
9572 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9573 PyObject *obj;
9574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9575 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9576 return SWIG_Py_Void();
9577 }
9578
9579 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9580 PyObject *resultobj = 0;
9581 wxInputStream *arg1 = (wxInputStream *) 0 ;
9582 wxString *arg2 = 0 ;
9583 wxString *arg3 = 0 ;
9584 wxString *arg4 = 0 ;
9585 wxDateTime arg5 ;
9586 wxFSFile *result = 0 ;
9587 wxPyInputStream *temp1 ;
9588 bool temp2 = false ;
9589 bool temp3 = false ;
9590 bool temp4 = false ;
9591 void *argp5 ;
9592 int res5 = 0 ;
9593 PyObject * obj0 = 0 ;
9594 PyObject * obj1 = 0 ;
9595 PyObject * obj2 = 0 ;
9596 PyObject * obj3 = 0 ;
9597 PyObject * obj4 = 0 ;
9598 char * kwnames[] = {
9599 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9600 };
9601
9602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9603 {
9604 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9605 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9606 } else {
9607 PyErr_Clear(); // clear the failure of the wxPyConvert above
9608 arg1 = wxPyCBInputStream_create(obj0, true);
9609 if (arg1 == NULL) {
9610 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9611 SWIG_fail;
9612 }
9613 }
9614 }
9615 {
9616 arg2 = wxString_in_helper(obj1);
9617 if (arg2 == NULL) SWIG_fail;
9618 temp2 = true;
9619 }
9620 {
9621 arg3 = wxString_in_helper(obj2);
9622 if (arg3 == NULL) SWIG_fail;
9623 temp3 = true;
9624 }
9625 {
9626 arg4 = wxString_in_helper(obj3);
9627 if (arg4 == NULL) SWIG_fail;
9628 temp4 = true;
9629 }
9630 {
9631 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9632 if (!SWIG_IsOK(res5)) {
9633 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9634 }
9635 if (!argp5) {
9636 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9637 } else {
9638 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9639 arg5 = *temp;
9640 if (SWIG_IsNewObj(res5)) delete temp;
9641 }
9642 }
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9646 wxPyEndAllowThreads(__tstate);
9647 if (PyErr_Occurred()) SWIG_fail;
9648 }
9649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9650 {
9651 if (temp2)
9652 delete arg2;
9653 }
9654 {
9655 if (temp3)
9656 delete arg3;
9657 }
9658 {
9659 if (temp4)
9660 delete arg4;
9661 }
9662 return resultobj;
9663 fail:
9664 {
9665 if (temp2)
9666 delete arg2;
9667 }
9668 {
9669 if (temp3)
9670 delete arg3;
9671 }
9672 {
9673 if (temp4)
9674 delete arg4;
9675 }
9676 return NULL;
9677 }
9678
9679
9680 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9681 PyObject *resultobj = 0;
9682 wxFSFile *arg1 = (wxFSFile *) 0 ;
9683 void *argp1 = 0 ;
9684 int res1 = 0 ;
9685 PyObject *swig_obj[1] ;
9686
9687 if (!args) SWIG_fail;
9688 swig_obj[0] = args;
9689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9690 if (!SWIG_IsOK(res1)) {
9691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9692 }
9693 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9694 {
9695 PyThreadState* __tstate = wxPyBeginAllowThreads();
9696 delete arg1;
9697
9698 wxPyEndAllowThreads(__tstate);
9699 if (PyErr_Occurred()) SWIG_fail;
9700 }
9701 resultobj = SWIG_Py_Void();
9702 return resultobj;
9703 fail:
9704 return NULL;
9705 }
9706
9707
9708 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9709 PyObject *resultobj = 0;
9710 wxFSFile *arg1 = (wxFSFile *) 0 ;
9711 wxInputStream *result = 0 ;
9712 void *argp1 = 0 ;
9713 int res1 = 0 ;
9714 PyObject *swig_obj[1] ;
9715
9716 if (!args) SWIG_fail;
9717 swig_obj[0] = args;
9718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9719 if (!SWIG_IsOK(res1)) {
9720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9721 }
9722 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 result = (wxInputStream *)(arg1)->GetStream();
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 {
9730 wxPyInputStream * _ptr = NULL;
9731
9732 if (result) {
9733 _ptr = new wxPyInputStream(result);
9734 }
9735 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9736 }
9737 return resultobj;
9738 fail:
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9744 PyObject *resultobj = 0;
9745 wxFSFile *arg1 = (wxFSFile *) 0 ;
9746 wxString *result = 0 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 PyObject *swig_obj[1] ;
9750
9751 if (!args) SWIG_fail;
9752 swig_obj[0] = args;
9753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9754 if (!SWIG_IsOK(res1)) {
9755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9756 }
9757 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 {
9761 wxString const &_result_ref = (arg1)->GetMimeType();
9762 result = (wxString *) &_result_ref;
9763 }
9764 wxPyEndAllowThreads(__tstate);
9765 if (PyErr_Occurred()) SWIG_fail;
9766 }
9767 {
9768 #if wxUSE_UNICODE
9769 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9770 #else
9771 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9772 #endif
9773 }
9774 return resultobj;
9775 fail:
9776 return NULL;
9777 }
9778
9779
9780 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9781 PyObject *resultobj = 0;
9782 wxFSFile *arg1 = (wxFSFile *) 0 ;
9783 wxString *result = 0 ;
9784 void *argp1 = 0 ;
9785 int res1 = 0 ;
9786 PyObject *swig_obj[1] ;
9787
9788 if (!args) SWIG_fail;
9789 swig_obj[0] = args;
9790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9791 if (!SWIG_IsOK(res1)) {
9792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9793 }
9794 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9795 {
9796 PyThreadState* __tstate = wxPyBeginAllowThreads();
9797 {
9798 wxString const &_result_ref = (arg1)->GetLocation();
9799 result = (wxString *) &_result_ref;
9800 }
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 {
9805 #if wxUSE_UNICODE
9806 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9807 #else
9808 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9809 #endif
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9818 PyObject *resultobj = 0;
9819 wxFSFile *arg1 = (wxFSFile *) 0 ;
9820 wxString *result = 0 ;
9821 void *argp1 = 0 ;
9822 int res1 = 0 ;
9823 PyObject *swig_obj[1] ;
9824
9825 if (!args) SWIG_fail;
9826 swig_obj[0] = args;
9827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9828 if (!SWIG_IsOK(res1)) {
9829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9830 }
9831 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9832 {
9833 PyThreadState* __tstate = wxPyBeginAllowThreads();
9834 {
9835 wxString const &_result_ref = (arg1)->GetAnchor();
9836 result = (wxString *) &_result_ref;
9837 }
9838 wxPyEndAllowThreads(__tstate);
9839 if (PyErr_Occurred()) SWIG_fail;
9840 }
9841 {
9842 #if wxUSE_UNICODE
9843 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9844 #else
9845 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9846 #endif
9847 }
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9855 PyObject *resultobj = 0;
9856 wxFSFile *arg1 = (wxFSFile *) 0 ;
9857 wxDateTime result;
9858 void *argp1 = 0 ;
9859 int res1 = 0 ;
9860 PyObject *swig_obj[1] ;
9861
9862 if (!args) SWIG_fail;
9863 swig_obj[0] = args;
9864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9865 if (!SWIG_IsOK(res1)) {
9866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9867 }
9868 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9869 {
9870 PyThreadState* __tstate = wxPyBeginAllowThreads();
9871 result = (arg1)->GetModificationTime();
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9883 PyObject *obj;
9884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9885 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9886 return SWIG_Py_Void();
9887 }
9888
9889 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890 return SWIG_Python_InitShadowInstance(args);
9891 }
9892
9893 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 PyObject *resultobj = 0;
9895 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 PyObject *swig_obj[1] ;
9899
9900 if (!args) SWIG_fail;
9901 swig_obj[0] = args;
9902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9903 if (!SWIG_IsOK(res1)) {
9904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9905 }
9906 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 delete arg1;
9910
9911 wxPyEndAllowThreads(__tstate);
9912 if (PyErr_Occurred()) SWIG_fail;
9913 }
9914 resultobj = SWIG_Py_Void();
9915 return resultobj;
9916 fail:
9917 return NULL;
9918 }
9919
9920
9921 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9922 PyObject *obj;
9923 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9924 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9925 return SWIG_Py_Void();
9926 }
9927
9928 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9929 PyObject *resultobj = 0;
9930 wxPyFileSystemHandler *result = 0 ;
9931
9932 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9947 PyObject *resultobj = 0;
9948 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9949 PyObject *arg2 = (PyObject *) 0 ;
9950 PyObject *arg3 = (PyObject *) 0 ;
9951 void *argp1 = 0 ;
9952 int res1 = 0 ;
9953 PyObject * obj0 = 0 ;
9954 PyObject * obj1 = 0 ;
9955 PyObject * obj2 = 0 ;
9956 char * kwnames[] = {
9957 (char *) "self",(char *) "self",(char *) "_class", NULL
9958 };
9959
9960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9962 if (!SWIG_IsOK(res1)) {
9963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9964 }
9965 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9966 arg2 = obj1;
9967 arg3 = obj2;
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 (arg1)->_setCallbackInfo(arg2,arg3);
9971 wxPyEndAllowThreads(__tstate);
9972 if (PyErr_Occurred()) SWIG_fail;
9973 }
9974 resultobj = SWIG_Py_Void();
9975 return resultobj;
9976 fail:
9977 return NULL;
9978 }
9979
9980
9981 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9982 PyObject *resultobj = 0;
9983 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9984 wxString *arg2 = 0 ;
9985 bool result;
9986 void *argp1 = 0 ;
9987 int res1 = 0 ;
9988 bool temp2 = false ;
9989 PyObject * obj0 = 0 ;
9990 PyObject * obj1 = 0 ;
9991 char * kwnames[] = {
9992 (char *) "self",(char *) "location", NULL
9993 };
9994
9995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9997 if (!SWIG_IsOK(res1)) {
9998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9999 }
10000 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10001 {
10002 arg2 = wxString_in_helper(obj1);
10003 if (arg2 == NULL) SWIG_fail;
10004 temp2 = true;
10005 }
10006 {
10007 PyThreadState* __tstate = wxPyBeginAllowThreads();
10008 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 {
10013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10014 }
10015 {
10016 if (temp2)
10017 delete arg2;
10018 }
10019 return resultobj;
10020 fail:
10021 {
10022 if (temp2)
10023 delete arg2;
10024 }
10025 return NULL;
10026 }
10027
10028
10029 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj = 0;
10031 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10032 wxFileSystem *arg2 = 0 ;
10033 wxString *arg3 = 0 ;
10034 wxFSFile *result = 0 ;
10035 void *argp1 = 0 ;
10036 int res1 = 0 ;
10037 void *argp2 = 0 ;
10038 int res2 = 0 ;
10039 bool temp3 = false ;
10040 PyObject * obj0 = 0 ;
10041 PyObject * obj1 = 0 ;
10042 PyObject * obj2 = 0 ;
10043 char * kwnames[] = {
10044 (char *) "self",(char *) "fs",(char *) "location", NULL
10045 };
10046
10047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10049 if (!SWIG_IsOK(res1)) {
10050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10051 }
10052 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10054 if (!SWIG_IsOK(res2)) {
10055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10056 }
10057 if (!argp2) {
10058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10059 }
10060 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10061 {
10062 arg3 = wxString_in_helper(obj2);
10063 if (arg3 == NULL) SWIG_fail;
10064 temp3 = true;
10065 }
10066 {
10067 PyThreadState* __tstate = wxPyBeginAllowThreads();
10068 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 {
10073 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10074 }
10075 {
10076 if (temp3)
10077 delete arg3;
10078 }
10079 return resultobj;
10080 fail:
10081 {
10082 if (temp3)
10083 delete arg3;
10084 }
10085 return NULL;
10086 }
10087
10088
10089 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10090 PyObject *resultobj = 0;
10091 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10092 wxString *arg2 = 0 ;
10093 int arg3 = (int) 0 ;
10094 wxString result;
10095 void *argp1 = 0 ;
10096 int res1 = 0 ;
10097 bool temp2 = false ;
10098 int val3 ;
10099 int ecode3 = 0 ;
10100 PyObject * obj0 = 0 ;
10101 PyObject * obj1 = 0 ;
10102 PyObject * obj2 = 0 ;
10103 char * kwnames[] = {
10104 (char *) "self",(char *) "spec",(char *) "flags", NULL
10105 };
10106
10107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10109 if (!SWIG_IsOK(res1)) {
10110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10111 }
10112 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10113 {
10114 arg2 = wxString_in_helper(obj1);
10115 if (arg2 == NULL) SWIG_fail;
10116 temp2 = true;
10117 }
10118 if (obj2) {
10119 ecode3 = SWIG_AsVal_int(obj2, &val3);
10120 if (!SWIG_IsOK(ecode3)) {
10121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10122 }
10123 arg3 = static_cast< int >(val3);
10124 }
10125 {
10126 PyThreadState* __tstate = wxPyBeginAllowThreads();
10127 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10128 wxPyEndAllowThreads(__tstate);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 {
10132 #if wxUSE_UNICODE
10133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10134 #else
10135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10136 #endif
10137 }
10138 {
10139 if (temp2)
10140 delete arg2;
10141 }
10142 return resultobj;
10143 fail:
10144 {
10145 if (temp2)
10146 delete arg2;
10147 }
10148 return NULL;
10149 }
10150
10151
10152 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10153 PyObject *resultobj = 0;
10154 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10155 wxString result;
10156 void *argp1 = 0 ;
10157 int res1 = 0 ;
10158 PyObject *swig_obj[1] ;
10159
10160 if (!args) SWIG_fail;
10161 swig_obj[0] = args;
10162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10163 if (!SWIG_IsOK(res1)) {
10164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10165 }
10166 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10167 {
10168 PyThreadState* __tstate = wxPyBeginAllowThreads();
10169 result = (arg1)->FindNext();
10170 wxPyEndAllowThreads(__tstate);
10171 if (PyErr_Occurred()) SWIG_fail;
10172 }
10173 {
10174 #if wxUSE_UNICODE
10175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10176 #else
10177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10178 #endif
10179 }
10180 return resultobj;
10181 fail:
10182 return NULL;
10183 }
10184
10185
10186 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10187 PyObject *resultobj = 0;
10188 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10189 wxString *arg2 = 0 ;
10190 wxString result;
10191 void *argp1 = 0 ;
10192 int res1 = 0 ;
10193 bool temp2 = false ;
10194 PyObject * obj0 = 0 ;
10195 PyObject * obj1 = 0 ;
10196 char * kwnames[] = {
10197 (char *) "self",(char *) "location", NULL
10198 };
10199
10200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10202 if (!SWIG_IsOK(res1)) {
10203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10204 }
10205 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10206 {
10207 arg2 = wxString_in_helper(obj1);
10208 if (arg2 == NULL) SWIG_fail;
10209 temp2 = true;
10210 }
10211 {
10212 PyThreadState* __tstate = wxPyBeginAllowThreads();
10213 result = (arg1)->GetProtocol((wxString const &)*arg2);
10214 wxPyEndAllowThreads(__tstate);
10215 if (PyErr_Occurred()) SWIG_fail;
10216 }
10217 {
10218 #if wxUSE_UNICODE
10219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10220 #else
10221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10222 #endif
10223 }
10224 {
10225 if (temp2)
10226 delete arg2;
10227 }
10228 return resultobj;
10229 fail:
10230 {
10231 if (temp2)
10232 delete arg2;
10233 }
10234 return NULL;
10235 }
10236
10237
10238 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj = 0;
10240 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10241 wxString *arg2 = 0 ;
10242 wxString result;
10243 void *argp1 = 0 ;
10244 int res1 = 0 ;
10245 bool temp2 = false ;
10246 PyObject * obj0 = 0 ;
10247 PyObject * obj1 = 0 ;
10248 char * kwnames[] = {
10249 (char *) "self",(char *) "location", NULL
10250 };
10251
10252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10254 if (!SWIG_IsOK(res1)) {
10255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10256 }
10257 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10258 {
10259 arg2 = wxString_in_helper(obj1);
10260 if (arg2 == NULL) SWIG_fail;
10261 temp2 = true;
10262 }
10263 {
10264 PyThreadState* __tstate = wxPyBeginAllowThreads();
10265 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10266 wxPyEndAllowThreads(__tstate);
10267 if (PyErr_Occurred()) SWIG_fail;
10268 }
10269 {
10270 #if wxUSE_UNICODE
10271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10272 #else
10273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10274 #endif
10275 }
10276 {
10277 if (temp2)
10278 delete arg2;
10279 }
10280 return resultobj;
10281 fail:
10282 {
10283 if (temp2)
10284 delete arg2;
10285 }
10286 return NULL;
10287 }
10288
10289
10290 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj = 0;
10292 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10293 wxString *arg2 = 0 ;
10294 wxString result;
10295 void *argp1 = 0 ;
10296 int res1 = 0 ;
10297 bool temp2 = false ;
10298 PyObject * obj0 = 0 ;
10299 PyObject * obj1 = 0 ;
10300 char * kwnames[] = {
10301 (char *) "self",(char *) "location", NULL
10302 };
10303
10304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10306 if (!SWIG_IsOK(res1)) {
10307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10308 }
10309 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10310 {
10311 arg2 = wxString_in_helper(obj1);
10312 if (arg2 == NULL) SWIG_fail;
10313 temp2 = true;
10314 }
10315 {
10316 PyThreadState* __tstate = wxPyBeginAllowThreads();
10317 result = (arg1)->GetAnchor((wxString const &)*arg2);
10318 wxPyEndAllowThreads(__tstate);
10319 if (PyErr_Occurred()) SWIG_fail;
10320 }
10321 {
10322 #if wxUSE_UNICODE
10323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10324 #else
10325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10326 #endif
10327 }
10328 {
10329 if (temp2)
10330 delete arg2;
10331 }
10332 return resultobj;
10333 fail:
10334 {
10335 if (temp2)
10336 delete arg2;
10337 }
10338 return NULL;
10339 }
10340
10341
10342 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10343 PyObject *resultobj = 0;
10344 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10345 wxString *arg2 = 0 ;
10346 wxString result;
10347 void *argp1 = 0 ;
10348 int res1 = 0 ;
10349 bool temp2 = false ;
10350 PyObject * obj0 = 0 ;
10351 PyObject * obj1 = 0 ;
10352 char * kwnames[] = {
10353 (char *) "self",(char *) "location", NULL
10354 };
10355
10356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10358 if (!SWIG_IsOK(res1)) {
10359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10360 }
10361 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10362 {
10363 arg2 = wxString_in_helper(obj1);
10364 if (arg2 == NULL) SWIG_fail;
10365 temp2 = true;
10366 }
10367 {
10368 PyThreadState* __tstate = wxPyBeginAllowThreads();
10369 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10370 wxPyEndAllowThreads(__tstate);
10371 if (PyErr_Occurred()) SWIG_fail;
10372 }
10373 {
10374 #if wxUSE_UNICODE
10375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10376 #else
10377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10378 #endif
10379 }
10380 {
10381 if (temp2)
10382 delete arg2;
10383 }
10384 return resultobj;
10385 fail:
10386 {
10387 if (temp2)
10388 delete arg2;
10389 }
10390 return NULL;
10391 }
10392
10393
10394 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10395 PyObject *resultobj = 0;
10396 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10397 wxString *arg2 = 0 ;
10398 wxString result;
10399 void *argp1 = 0 ;
10400 int res1 = 0 ;
10401 bool temp2 = false ;
10402 PyObject * obj0 = 0 ;
10403 PyObject * obj1 = 0 ;
10404 char * kwnames[] = {
10405 (char *) "self",(char *) "location", NULL
10406 };
10407
10408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10410 if (!SWIG_IsOK(res1)) {
10411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10412 }
10413 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10414 {
10415 arg2 = wxString_in_helper(obj1);
10416 if (arg2 == NULL) SWIG_fail;
10417 temp2 = true;
10418 }
10419 {
10420 PyThreadState* __tstate = wxPyBeginAllowThreads();
10421 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10422 wxPyEndAllowThreads(__tstate);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 {
10426 #if wxUSE_UNICODE
10427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10428 #else
10429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10430 #endif
10431 }
10432 {
10433 if (temp2)
10434 delete arg2;
10435 }
10436 return resultobj;
10437 fail:
10438 {
10439 if (temp2)
10440 delete arg2;
10441 }
10442 return NULL;
10443 }
10444
10445
10446 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10447 PyObject *obj;
10448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10449 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10450 return SWIG_Py_Void();
10451 }
10452
10453 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10454 return SWIG_Python_InitShadowInstance(args);
10455 }
10456
10457 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10458 PyObject *resultobj = 0;
10459 wxFileSystem *result = 0 ;
10460
10461 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10462 {
10463 PyThreadState* __tstate = wxPyBeginAllowThreads();
10464 result = (wxFileSystem *)new wxFileSystem();
10465 wxPyEndAllowThreads(__tstate);
10466 if (PyErr_Occurred()) SWIG_fail;
10467 }
10468 {
10469 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10470 }
10471 return resultobj;
10472 fail:
10473 return NULL;
10474 }
10475
10476
10477 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10478 PyObject *resultobj = 0;
10479 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10480 void *argp1 = 0 ;
10481 int res1 = 0 ;
10482 PyObject *swig_obj[1] ;
10483
10484 if (!args) SWIG_fail;
10485 swig_obj[0] = args;
10486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10487 if (!SWIG_IsOK(res1)) {
10488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10489 }
10490 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10491 {
10492 PyThreadState* __tstate = wxPyBeginAllowThreads();
10493 delete arg1;
10494
10495 wxPyEndAllowThreads(__tstate);
10496 if (PyErr_Occurred()) SWIG_fail;
10497 }
10498 resultobj = SWIG_Py_Void();
10499 return resultobj;
10500 fail:
10501 return NULL;
10502 }
10503
10504
10505 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10506 PyObject *resultobj = 0;
10507 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10508 wxString *arg2 = 0 ;
10509 bool arg3 = (bool) false ;
10510 void *argp1 = 0 ;
10511 int res1 = 0 ;
10512 bool temp2 = false ;
10513 bool val3 ;
10514 int ecode3 = 0 ;
10515 PyObject * obj0 = 0 ;
10516 PyObject * obj1 = 0 ;
10517 PyObject * obj2 = 0 ;
10518 char * kwnames[] = {
10519 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10520 };
10521
10522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10524 if (!SWIG_IsOK(res1)) {
10525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10526 }
10527 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10528 {
10529 arg2 = wxString_in_helper(obj1);
10530 if (arg2 == NULL) SWIG_fail;
10531 temp2 = true;
10532 }
10533 if (obj2) {
10534 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10535 if (!SWIG_IsOK(ecode3)) {
10536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10537 }
10538 arg3 = static_cast< bool >(val3);
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 resultobj = SWIG_Py_Void();
10547 {
10548 if (temp2)
10549 delete arg2;
10550 }
10551 return resultobj;
10552 fail:
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return NULL;
10558 }
10559
10560
10561 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10562 PyObject *resultobj = 0;
10563 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10564 wxString result;
10565 void *argp1 = 0 ;
10566 int res1 = 0 ;
10567 PyObject *swig_obj[1] ;
10568
10569 if (!args) SWIG_fail;
10570 swig_obj[0] = args;
10571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10572 if (!SWIG_IsOK(res1)) {
10573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10574 }
10575 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10576 {
10577 PyThreadState* __tstate = wxPyBeginAllowThreads();
10578 result = (arg1)->GetPath();
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 {
10583 #if wxUSE_UNICODE
10584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10585 #else
10586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10587 #endif
10588 }
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10596 PyObject *resultobj = 0;
10597 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10598 wxString *arg2 = 0 ;
10599 wxFSFile *result = 0 ;
10600 void *argp1 = 0 ;
10601 int res1 = 0 ;
10602 bool temp2 = false ;
10603 PyObject * obj0 = 0 ;
10604 PyObject * obj1 = 0 ;
10605 char * kwnames[] = {
10606 (char *) "self",(char *) "location", NULL
10607 };
10608
10609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10611 if (!SWIG_IsOK(res1)) {
10612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10613 }
10614 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10615 {
10616 arg2 = wxString_in_helper(obj1);
10617 if (arg2 == NULL) SWIG_fail;
10618 temp2 = true;
10619 }
10620 {
10621 PyThreadState* __tstate = wxPyBeginAllowThreads();
10622 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10623 wxPyEndAllowThreads(__tstate);
10624 if (PyErr_Occurred()) SWIG_fail;
10625 }
10626 {
10627 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10628 }
10629 {
10630 if (temp2)
10631 delete arg2;
10632 }
10633 return resultobj;
10634 fail:
10635 {
10636 if (temp2)
10637 delete arg2;
10638 }
10639 return NULL;
10640 }
10641
10642
10643 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10644 PyObject *resultobj = 0;
10645 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10646 wxString *arg2 = 0 ;
10647 int arg3 = (int) 0 ;
10648 wxString result;
10649 void *argp1 = 0 ;
10650 int res1 = 0 ;
10651 bool temp2 = false ;
10652 int val3 ;
10653 int ecode3 = 0 ;
10654 PyObject * obj0 = 0 ;
10655 PyObject * obj1 = 0 ;
10656 PyObject * obj2 = 0 ;
10657 char * kwnames[] = {
10658 (char *) "self",(char *) "spec",(char *) "flags", NULL
10659 };
10660
10661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10663 if (!SWIG_IsOK(res1)) {
10664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10665 }
10666 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10667 {
10668 arg2 = wxString_in_helper(obj1);
10669 if (arg2 == NULL) SWIG_fail;
10670 temp2 = true;
10671 }
10672 if (obj2) {
10673 ecode3 = SWIG_AsVal_int(obj2, &val3);
10674 if (!SWIG_IsOK(ecode3)) {
10675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10676 }
10677 arg3 = static_cast< int >(val3);
10678 }
10679 {
10680 PyThreadState* __tstate = wxPyBeginAllowThreads();
10681 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10682 wxPyEndAllowThreads(__tstate);
10683 if (PyErr_Occurred()) SWIG_fail;
10684 }
10685 {
10686 #if wxUSE_UNICODE
10687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10688 #else
10689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10690 #endif
10691 }
10692 {
10693 if (temp2)
10694 delete arg2;
10695 }
10696 return resultobj;
10697 fail:
10698 {
10699 if (temp2)
10700 delete arg2;
10701 }
10702 return NULL;
10703 }
10704
10705
10706 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10707 PyObject *resultobj = 0;
10708 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10709 wxString result;
10710 void *argp1 = 0 ;
10711 int res1 = 0 ;
10712 PyObject *swig_obj[1] ;
10713
10714 if (!args) SWIG_fail;
10715 swig_obj[0] = args;
10716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10717 if (!SWIG_IsOK(res1)) {
10718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10719 }
10720 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10721 {
10722 PyThreadState* __tstate = wxPyBeginAllowThreads();
10723 result = (arg1)->FindNext();
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 {
10728 #if wxUSE_UNICODE
10729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10730 #else
10731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10732 #endif
10733 }
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10741 PyObject *resultobj = 0;
10742 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10743 int res1 = 0 ;
10744 PyObject * obj0 = 0 ;
10745 char * kwnames[] = {
10746 (char *) "handler", NULL
10747 };
10748
10749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10750 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10751 if (!SWIG_IsOK(res1)) {
10752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10753 }
10754 {
10755 PyThreadState* __tstate = wxPyBeginAllowThreads();
10756 wxFileSystem::AddHandler(arg1);
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 resultobj = SWIG_Py_Void();
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10768 PyObject *resultobj = 0;
10769
10770 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10771 {
10772 PyThreadState* __tstate = wxPyBeginAllowThreads();
10773 wxFileSystem::CleanUpHandlers();
10774 wxPyEndAllowThreads(__tstate);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 resultobj = SWIG_Py_Void();
10778 return resultobj;
10779 fail:
10780 return NULL;
10781 }
10782
10783
10784 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10785 PyObject *resultobj = 0;
10786 wxString *arg1 = 0 ;
10787 wxString result;
10788 bool temp1 = false ;
10789 PyObject * obj0 = 0 ;
10790 char * kwnames[] = {
10791 (char *) "filename", NULL
10792 };
10793
10794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10795 {
10796 arg1 = wxString_in_helper(obj0);
10797 if (arg1 == NULL) SWIG_fail;
10798 temp1 = true;
10799 }
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 {
10807 #if wxUSE_UNICODE
10808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10809 #else
10810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10811 #endif
10812 }
10813 {
10814 if (temp1)
10815 delete arg1;
10816 }
10817 return resultobj;
10818 fail:
10819 {
10820 if (temp1)
10821 delete arg1;
10822 }
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = 0;
10829 wxString *arg1 = 0 ;
10830 wxString result;
10831 bool temp1 = false ;
10832 PyObject * obj0 = 0 ;
10833 char * kwnames[] = {
10834 (char *) "url", NULL
10835 };
10836
10837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10838 {
10839 arg1 = wxString_in_helper(obj0);
10840 if (arg1 == NULL) SWIG_fail;
10841 temp1 = true;
10842 }
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 {
10850 #if wxUSE_UNICODE
10851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10852 #else
10853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10854 #endif
10855 }
10856 {
10857 if (temp1)
10858 delete arg1;
10859 }
10860 return resultobj;
10861 fail:
10862 {
10863 if (temp1)
10864 delete arg1;
10865 }
10866 return NULL;
10867 }
10868
10869
10870 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10871 PyObject *obj;
10872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10873 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10874 return SWIG_Py_Void();
10875 }
10876
10877 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878 return SWIG_Python_InitShadowInstance(args);
10879 }
10880
10881 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10882 PyObject *resultobj = 0;
10883 wxInternetFSHandler *result = 0 ;
10884
10885 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10886 {
10887 PyThreadState* __tstate = wxPyBeginAllowThreads();
10888 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10889 wxPyEndAllowThreads(__tstate);
10890 if (PyErr_Occurred()) SWIG_fail;
10891 }
10892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10893 return resultobj;
10894 fail:
10895 return NULL;
10896 }
10897
10898
10899 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10900 PyObject *resultobj = 0;
10901 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10902 wxString *arg2 = 0 ;
10903 bool result;
10904 void *argp1 = 0 ;
10905 int res1 = 0 ;
10906 bool temp2 = false ;
10907 PyObject * obj0 = 0 ;
10908 PyObject * obj1 = 0 ;
10909 char * kwnames[] = {
10910 (char *) "self",(char *) "location", NULL
10911 };
10912
10913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10915 if (!SWIG_IsOK(res1)) {
10916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10917 }
10918 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10919 {
10920 arg2 = wxString_in_helper(obj1);
10921 if (arg2 == NULL) SWIG_fail;
10922 temp2 = true;
10923 }
10924 {
10925 PyThreadState* __tstate = wxPyBeginAllowThreads();
10926 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10927 wxPyEndAllowThreads(__tstate);
10928 if (PyErr_Occurred()) SWIG_fail;
10929 }
10930 {
10931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10932 }
10933 {
10934 if (temp2)
10935 delete arg2;
10936 }
10937 return resultobj;
10938 fail:
10939 {
10940 if (temp2)
10941 delete arg2;
10942 }
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10950 wxFileSystem *arg2 = 0 ;
10951 wxString *arg3 = 0 ;
10952 wxFSFile *result = 0 ;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 void *argp2 = 0 ;
10956 int res2 = 0 ;
10957 bool temp3 = false ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 PyObject * obj2 = 0 ;
10961 char * kwnames[] = {
10962 (char *) "self",(char *) "fs",(char *) "location", NULL
10963 };
10964
10965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10967 if (!SWIG_IsOK(res1)) {
10968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10969 }
10970 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10971 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10972 if (!SWIG_IsOK(res2)) {
10973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10974 }
10975 if (!argp2) {
10976 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10977 }
10978 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10979 {
10980 arg3 = wxString_in_helper(obj2);
10981 if (arg3 == NULL) SWIG_fail;
10982 temp3 = true;
10983 }
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10987 wxPyEndAllowThreads(__tstate);
10988 if (PyErr_Occurred()) SWIG_fail;
10989 }
10990 {
10991 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10992 }
10993 {
10994 if (temp3)
10995 delete arg3;
10996 }
10997 return resultobj;
10998 fail:
10999 {
11000 if (temp3)
11001 delete arg3;
11002 }
11003 return NULL;
11004 }
11005
11006
11007 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11008 PyObject *obj;
11009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11010 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11011 return SWIG_Py_Void();
11012 }
11013
11014 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11015 return SWIG_Python_InitShadowInstance(args);
11016 }
11017
11018 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 PyObject *resultobj = 0;
11020 wxZipFSHandler *result = 0 ;
11021
11022 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11023 {
11024 PyThreadState* __tstate = wxPyBeginAllowThreads();
11025 result = (wxZipFSHandler *)new wxZipFSHandler();
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11037 PyObject *resultobj = 0;
11038 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11039 wxString *arg2 = 0 ;
11040 bool result;
11041 void *argp1 = 0 ;
11042 int res1 = 0 ;
11043 bool temp2 = false ;
11044 PyObject * obj0 = 0 ;
11045 PyObject * obj1 = 0 ;
11046 char * kwnames[] = {
11047 (char *) "self",(char *) "location", NULL
11048 };
11049
11050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11052 if (!SWIG_IsOK(res1)) {
11053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11054 }
11055 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11056 {
11057 arg2 = wxString_in_helper(obj1);
11058 if (arg2 == NULL) SWIG_fail;
11059 temp2 = true;
11060 }
11061 {
11062 PyThreadState* __tstate = wxPyBeginAllowThreads();
11063 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 {
11068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11069 }
11070 {
11071 if (temp2)
11072 delete arg2;
11073 }
11074 return resultobj;
11075 fail:
11076 {
11077 if (temp2)
11078 delete arg2;
11079 }
11080 return NULL;
11081 }
11082
11083
11084 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11085 PyObject *resultobj = 0;
11086 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11087 wxFileSystem *arg2 = 0 ;
11088 wxString *arg3 = 0 ;
11089 wxFSFile *result = 0 ;
11090 void *argp1 = 0 ;
11091 int res1 = 0 ;
11092 void *argp2 = 0 ;
11093 int res2 = 0 ;
11094 bool temp3 = false ;
11095 PyObject * obj0 = 0 ;
11096 PyObject * obj1 = 0 ;
11097 PyObject * obj2 = 0 ;
11098 char * kwnames[] = {
11099 (char *) "self",(char *) "fs",(char *) "location", NULL
11100 };
11101
11102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11104 if (!SWIG_IsOK(res1)) {
11105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11106 }
11107 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11108 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11109 if (!SWIG_IsOK(res2)) {
11110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11111 }
11112 if (!argp2) {
11113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11114 }
11115 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11116 {
11117 arg3 = wxString_in_helper(obj2);
11118 if (arg3 == NULL) SWIG_fail;
11119 temp3 = true;
11120 }
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11124 wxPyEndAllowThreads(__tstate);
11125 if (PyErr_Occurred()) SWIG_fail;
11126 }
11127 {
11128 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11129 }
11130 {
11131 if (temp3)
11132 delete arg3;
11133 }
11134 return resultobj;
11135 fail:
11136 {
11137 if (temp3)
11138 delete arg3;
11139 }
11140 return NULL;
11141 }
11142
11143
11144 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11145 PyObject *resultobj = 0;
11146 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11147 wxString *arg2 = 0 ;
11148 int arg3 = (int) 0 ;
11149 wxString result;
11150 void *argp1 = 0 ;
11151 int res1 = 0 ;
11152 bool temp2 = false ;
11153 int val3 ;
11154 int ecode3 = 0 ;
11155 PyObject * obj0 = 0 ;
11156 PyObject * obj1 = 0 ;
11157 PyObject * obj2 = 0 ;
11158 char * kwnames[] = {
11159 (char *) "self",(char *) "spec",(char *) "flags", NULL
11160 };
11161
11162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11164 if (!SWIG_IsOK(res1)) {
11165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11166 }
11167 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11168 {
11169 arg2 = wxString_in_helper(obj1);
11170 if (arg2 == NULL) SWIG_fail;
11171 temp2 = true;
11172 }
11173 if (obj2) {
11174 ecode3 = SWIG_AsVal_int(obj2, &val3);
11175 if (!SWIG_IsOK(ecode3)) {
11176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11177 }
11178 arg3 = static_cast< int >(val3);
11179 }
11180 {
11181 PyThreadState* __tstate = wxPyBeginAllowThreads();
11182 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11183 wxPyEndAllowThreads(__tstate);
11184 if (PyErr_Occurred()) SWIG_fail;
11185 }
11186 {
11187 #if wxUSE_UNICODE
11188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11189 #else
11190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11191 #endif
11192 }
11193 {
11194 if (temp2)
11195 delete arg2;
11196 }
11197 return resultobj;
11198 fail:
11199 {
11200 if (temp2)
11201 delete arg2;
11202 }
11203 return NULL;
11204 }
11205
11206
11207 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11208 PyObject *resultobj = 0;
11209 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11210 wxString result;
11211 void *argp1 = 0 ;
11212 int res1 = 0 ;
11213 PyObject *swig_obj[1] ;
11214
11215 if (!args) SWIG_fail;
11216 swig_obj[0] = args;
11217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11218 if (!SWIG_IsOK(res1)) {
11219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11220 }
11221 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11222 {
11223 PyThreadState* __tstate = wxPyBeginAllowThreads();
11224 result = (arg1)->FindNext();
11225 wxPyEndAllowThreads(__tstate);
11226 if (PyErr_Occurred()) SWIG_fail;
11227 }
11228 {
11229 #if wxUSE_UNICODE
11230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11231 #else
11232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11233 #endif
11234 }
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11242 PyObject *obj;
11243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11244 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11245 return SWIG_Py_Void();
11246 }
11247
11248 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11249 return SWIG_Python_InitShadowInstance(args);
11250 }
11251
11252 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11253 PyObject *resultobj = 0;
11254 wxString *arg1 = 0 ;
11255 wxImage *arg2 = 0 ;
11256 long arg3 ;
11257 bool temp1 = false ;
11258 void *argp2 = 0 ;
11259 int res2 = 0 ;
11260 long val3 ;
11261 int ecode3 = 0 ;
11262 PyObject * obj0 = 0 ;
11263 PyObject * obj1 = 0 ;
11264 PyObject * obj2 = 0 ;
11265 char * kwnames[] = {
11266 (char *) "filename",(char *) "image",(char *) "type", NULL
11267 };
11268
11269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11270 {
11271 arg1 = wxString_in_helper(obj0);
11272 if (arg1 == NULL) SWIG_fail;
11273 temp1 = true;
11274 }
11275 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11276 if (!SWIG_IsOK(res2)) {
11277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11278 }
11279 if (!argp2) {
11280 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11281 }
11282 arg2 = reinterpret_cast< wxImage * >(argp2);
11283 ecode3 = SWIG_AsVal_long(obj2, &val3);
11284 if (!SWIG_IsOK(ecode3)) {
11285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11286 }
11287 arg3 = static_cast< long >(val3);
11288 {
11289 PyThreadState* __tstate = wxPyBeginAllowThreads();
11290 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11291 wxPyEndAllowThreads(__tstate);
11292 if (PyErr_Occurred()) SWIG_fail;
11293 }
11294 resultobj = SWIG_Py_Void();
11295 {
11296 if (temp1)
11297 delete arg1;
11298 }
11299 return resultobj;
11300 fail:
11301 {
11302 if (temp1)
11303 delete arg1;
11304 }
11305 return NULL;
11306 }
11307
11308
11309 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj = 0;
11311 wxString *arg1 = 0 ;
11312 wxBitmap *arg2 = 0 ;
11313 long arg3 ;
11314 bool temp1 = false ;
11315 void *argp2 = 0 ;
11316 int res2 = 0 ;
11317 long val3 ;
11318 int ecode3 = 0 ;
11319 PyObject * obj0 = 0 ;
11320 PyObject * obj1 = 0 ;
11321 PyObject * obj2 = 0 ;
11322 char * kwnames[] = {
11323 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11324 };
11325
11326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11327 {
11328 arg1 = wxString_in_helper(obj0);
11329 if (arg1 == NULL) SWIG_fail;
11330 temp1 = true;
11331 }
11332 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11333 if (!SWIG_IsOK(res2)) {
11334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11335 }
11336 if (!argp2) {
11337 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11338 }
11339 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11340 ecode3 = SWIG_AsVal_long(obj2, &val3);
11341 if (!SWIG_IsOK(ecode3)) {
11342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11343 }
11344 arg3 = static_cast< long >(val3);
11345 {
11346 PyThreadState* __tstate = wxPyBeginAllowThreads();
11347 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11348 wxPyEndAllowThreads(__tstate);
11349 if (PyErr_Occurred()) SWIG_fail;
11350 }
11351 resultobj = SWIG_Py_Void();
11352 {
11353 if (temp1)
11354 delete arg1;
11355 }
11356 return resultobj;
11357 fail:
11358 {
11359 if (temp1)
11360 delete arg1;
11361 }
11362 return NULL;
11363 }
11364
11365
11366 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11367 PyObject *resultobj = 0;
11368 wxString *arg1 = 0 ;
11369 PyObject *arg2 = (PyObject *) 0 ;
11370 bool temp1 = false ;
11371 PyObject * obj0 = 0 ;
11372 PyObject * obj1 = 0 ;
11373 char * kwnames[] = {
11374 (char *) "filename",(char *) "data", NULL
11375 };
11376
11377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11378 {
11379 arg1 = wxString_in_helper(obj0);
11380 if (arg1 == NULL) SWIG_fail;
11381 temp1 = true;
11382 }
11383 arg2 = obj1;
11384 {
11385 PyThreadState* __tstate = wxPyBeginAllowThreads();
11386 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11387 wxPyEndAllowThreads(__tstate);
11388 if (PyErr_Occurred()) SWIG_fail;
11389 }
11390 resultobj = SWIG_Py_Void();
11391 {
11392 if (temp1)
11393 delete arg1;
11394 }
11395 return resultobj;
11396 fail:
11397 {
11398 if (temp1)
11399 delete arg1;
11400 }
11401 return NULL;
11402 }
11403
11404
11405 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11406 PyObject *resultobj = 0;
11407 wxMemoryFSHandler *result = 0 ;
11408
11409 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11410 {
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11417 return resultobj;
11418 fail:
11419 return NULL;
11420 }
11421
11422
11423 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11424 PyObject *resultobj = 0;
11425 wxString *arg1 = 0 ;
11426 bool temp1 = false ;
11427 PyObject * obj0 = 0 ;
11428 char * kwnames[] = {
11429 (char *) "filename", NULL
11430 };
11431
11432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11433 {
11434 arg1 = wxString_in_helper(obj0);
11435 if (arg1 == NULL) SWIG_fail;
11436 temp1 = true;
11437 }
11438 {
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11441 wxPyEndAllowThreads(__tstate);
11442 if (PyErr_Occurred()) SWIG_fail;
11443 }
11444 resultobj = SWIG_Py_Void();
11445 {
11446 if (temp1)
11447 delete arg1;
11448 }
11449 return resultobj;
11450 fail:
11451 {
11452 if (temp1)
11453 delete arg1;
11454 }
11455 return NULL;
11456 }
11457
11458
11459 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11460 PyObject *resultobj = 0;
11461 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11462 wxString *arg2 = 0 ;
11463 bool result;
11464 void *argp1 = 0 ;
11465 int res1 = 0 ;
11466 bool temp2 = false ;
11467 PyObject * obj0 = 0 ;
11468 PyObject * obj1 = 0 ;
11469 char * kwnames[] = {
11470 (char *) "self",(char *) "location", NULL
11471 };
11472
11473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11475 if (!SWIG_IsOK(res1)) {
11476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11477 }
11478 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11479 {
11480 arg2 = wxString_in_helper(obj1);
11481 if (arg2 == NULL) SWIG_fail;
11482 temp2 = true;
11483 }
11484 {
11485 PyThreadState* __tstate = wxPyBeginAllowThreads();
11486 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11487 wxPyEndAllowThreads(__tstate);
11488 if (PyErr_Occurred()) SWIG_fail;
11489 }
11490 {
11491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11492 }
11493 {
11494 if (temp2)
11495 delete arg2;
11496 }
11497 return resultobj;
11498 fail:
11499 {
11500 if (temp2)
11501 delete arg2;
11502 }
11503 return NULL;
11504 }
11505
11506
11507 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj = 0;
11509 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11510 wxFileSystem *arg2 = 0 ;
11511 wxString *arg3 = 0 ;
11512 wxFSFile *result = 0 ;
11513 void *argp1 = 0 ;
11514 int res1 = 0 ;
11515 void *argp2 = 0 ;
11516 int res2 = 0 ;
11517 bool temp3 = false ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 PyObject * obj2 = 0 ;
11521 char * kwnames[] = {
11522 (char *) "self",(char *) "fs",(char *) "location", NULL
11523 };
11524
11525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11527 if (!SWIG_IsOK(res1)) {
11528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11529 }
11530 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11532 if (!SWIG_IsOK(res2)) {
11533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11534 }
11535 if (!argp2) {
11536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11537 }
11538 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11539 {
11540 arg3 = wxString_in_helper(obj2);
11541 if (arg3 == NULL) SWIG_fail;
11542 temp3 = true;
11543 }
11544 {
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 {
11551 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11552 }
11553 {
11554 if (temp3)
11555 delete arg3;
11556 }
11557 return resultobj;
11558 fail:
11559 {
11560 if (temp3)
11561 delete arg3;
11562 }
11563 return NULL;
11564 }
11565
11566
11567 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11568 PyObject *resultobj = 0;
11569 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11570 wxString *arg2 = 0 ;
11571 int arg3 = (int) 0 ;
11572 wxString result;
11573 void *argp1 = 0 ;
11574 int res1 = 0 ;
11575 bool temp2 = false ;
11576 int val3 ;
11577 int ecode3 = 0 ;
11578 PyObject * obj0 = 0 ;
11579 PyObject * obj1 = 0 ;
11580 PyObject * obj2 = 0 ;
11581 char * kwnames[] = {
11582 (char *) "self",(char *) "spec",(char *) "flags", NULL
11583 };
11584
11585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11587 if (!SWIG_IsOK(res1)) {
11588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11589 }
11590 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11591 {
11592 arg2 = wxString_in_helper(obj1);
11593 if (arg2 == NULL) SWIG_fail;
11594 temp2 = true;
11595 }
11596 if (obj2) {
11597 ecode3 = SWIG_AsVal_int(obj2, &val3);
11598 if (!SWIG_IsOK(ecode3)) {
11599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11600 }
11601 arg3 = static_cast< int >(val3);
11602 }
11603 {
11604 PyThreadState* __tstate = wxPyBeginAllowThreads();
11605 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11606 wxPyEndAllowThreads(__tstate);
11607 if (PyErr_Occurred()) SWIG_fail;
11608 }
11609 {
11610 #if wxUSE_UNICODE
11611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11612 #else
11613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11614 #endif
11615 }
11616 {
11617 if (temp2)
11618 delete arg2;
11619 }
11620 return resultobj;
11621 fail:
11622 {
11623 if (temp2)
11624 delete arg2;
11625 }
11626 return NULL;
11627 }
11628
11629
11630 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11631 PyObject *resultobj = 0;
11632 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11633 wxString result;
11634 void *argp1 = 0 ;
11635 int res1 = 0 ;
11636 PyObject *swig_obj[1] ;
11637
11638 if (!args) SWIG_fail;
11639 swig_obj[0] = args;
11640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11641 if (!SWIG_IsOK(res1)) {
11642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11643 }
11644 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11645 {
11646 PyThreadState* __tstate = wxPyBeginAllowThreads();
11647 result = (arg1)->FindNext();
11648 wxPyEndAllowThreads(__tstate);
11649 if (PyErr_Occurred()) SWIG_fail;
11650 }
11651 {
11652 #if wxUSE_UNICODE
11653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11654 #else
11655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11656 #endif
11657 }
11658 return resultobj;
11659 fail:
11660 return NULL;
11661 }
11662
11663
11664 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11665 PyObject *obj;
11666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11667 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11668 return SWIG_Py_Void();
11669 }
11670
11671 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11672 return SWIG_Python_InitShadowInstance(args);
11673 }
11674
11675 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11676 PyObject *resultobj = 0;
11677 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11678 wxString result;
11679 void *argp1 = 0 ;
11680 int res1 = 0 ;
11681 PyObject *swig_obj[1] ;
11682
11683 if (!args) SWIG_fail;
11684 swig_obj[0] = args;
11685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11686 if (!SWIG_IsOK(res1)) {
11687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11688 }
11689 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = (arg1)->GetName();
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 {
11697 #if wxUSE_UNICODE
11698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11699 #else
11700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11701 #endif
11702 }
11703 return resultobj;
11704 fail:
11705 return NULL;
11706 }
11707
11708
11709 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11710 PyObject *resultobj = 0;
11711 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11712 wxString result;
11713 void *argp1 = 0 ;
11714 int res1 = 0 ;
11715 PyObject *swig_obj[1] ;
11716
11717 if (!args) SWIG_fail;
11718 swig_obj[0] = args;
11719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11720 if (!SWIG_IsOK(res1)) {
11721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11722 }
11723 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 result = (arg1)->GetExtension();
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 {
11731 #if wxUSE_UNICODE
11732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11733 #else
11734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11735 #endif
11736 }
11737 return resultobj;
11738 fail:
11739 return NULL;
11740 }
11741
11742
11743 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11744 PyObject *resultobj = 0;
11745 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11746 long result;
11747 void *argp1 = 0 ;
11748 int res1 = 0 ;
11749 PyObject *swig_obj[1] ;
11750
11751 if (!args) SWIG_fail;
11752 swig_obj[0] = args;
11753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11754 if (!SWIG_IsOK(res1)) {
11755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11756 }
11757 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11758 {
11759 PyThreadState* __tstate = wxPyBeginAllowThreads();
11760 result = (long)(arg1)->GetType();
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 resultobj = SWIG_From_long(static_cast< long >(result));
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11772 PyObject *resultobj = 0;
11773 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11774 wxString result;
11775 void *argp1 = 0 ;
11776 int res1 = 0 ;
11777 PyObject *swig_obj[1] ;
11778
11779 if (!args) SWIG_fail;
11780 swig_obj[0] = args;
11781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11784 }
11785 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11786 {
11787 PyThreadState* __tstate = wxPyBeginAllowThreads();
11788 result = (arg1)->GetMimeType();
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 {
11793 #if wxUSE_UNICODE
11794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11795 #else
11796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11797 #endif
11798 }
11799 return resultobj;
11800 fail:
11801 return NULL;
11802 }
11803
11804
11805 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11806 PyObject *resultobj = 0;
11807 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11808 wxString *arg2 = 0 ;
11809 bool result;
11810 void *argp1 = 0 ;
11811 int res1 = 0 ;
11812 bool temp2 = false ;
11813 PyObject * obj0 = 0 ;
11814 PyObject * obj1 = 0 ;
11815 char * kwnames[] = {
11816 (char *) "self",(char *) "name", NULL
11817 };
11818
11819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11821 if (!SWIG_IsOK(res1)) {
11822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11823 }
11824 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11825 {
11826 arg2 = wxString_in_helper(obj1);
11827 if (arg2 == NULL) SWIG_fail;
11828 temp2 = true;
11829 }
11830 {
11831 PyThreadState* __tstate = wxPyBeginAllowThreads();
11832 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11833 wxPyEndAllowThreads(__tstate);
11834 if (PyErr_Occurred()) SWIG_fail;
11835 }
11836 {
11837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11838 }
11839 {
11840 if (temp2)
11841 delete arg2;
11842 }
11843 return resultobj;
11844 fail:
11845 {
11846 if (temp2)
11847 delete arg2;
11848 }
11849 return NULL;
11850 }
11851
11852
11853 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj = 0;
11855 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11856 wxInputStream *arg2 = 0 ;
11857 bool result;
11858 void *argp1 = 0 ;
11859 int res1 = 0 ;
11860 wxPyInputStream *temp2 ;
11861 bool created2 ;
11862 PyObject * obj0 = 0 ;
11863 PyObject * obj1 = 0 ;
11864 char * kwnames[] = {
11865 (char *) "self",(char *) "stream", NULL
11866 };
11867
11868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11870 if (!SWIG_IsOK(res1)) {
11871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11872 }
11873 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11874 {
11875 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11876 arg2 = temp2->m_wxis;
11877 created2 = false;
11878 } else {
11879 PyErr_Clear(); // clear the failure of the wxPyConvert above
11880 arg2 = wxPyCBInputStream_create(obj1, false);
11881 if (arg2 == NULL) {
11882 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11883 SWIG_fail;
11884 }
11885 created2 = true;
11886 }
11887 }
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (bool)(arg1)->CanRead(*arg2);
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11896 }
11897 {
11898 if (created2) delete arg2;
11899 }
11900 return resultobj;
11901 fail:
11902 {
11903 if (created2) delete arg2;
11904 }
11905 return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj = 0;
11911 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11912 wxString *arg2 = 0 ;
11913 void *argp1 = 0 ;
11914 int res1 = 0 ;
11915 bool temp2 = false ;
11916 PyObject * obj0 = 0 ;
11917 PyObject * obj1 = 0 ;
11918 char * kwnames[] = {
11919 (char *) "self",(char *) "name", NULL
11920 };
11921
11922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11924 if (!SWIG_IsOK(res1)) {
11925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11926 }
11927 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11928 {
11929 arg2 = wxString_in_helper(obj1);
11930 if (arg2 == NULL) SWIG_fail;
11931 temp2 = true;
11932 }
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 (arg1)->SetName((wxString const &)*arg2);
11936 wxPyEndAllowThreads(__tstate);
11937 if (PyErr_Occurred()) SWIG_fail;
11938 }
11939 resultobj = SWIG_Py_Void();
11940 {
11941 if (temp2)
11942 delete arg2;
11943 }
11944 return resultobj;
11945 fail:
11946 {
11947 if (temp2)
11948 delete arg2;
11949 }
11950 return NULL;
11951 }
11952
11953
11954 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj = 0;
11956 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11957 wxString *arg2 = 0 ;
11958 void *argp1 = 0 ;
11959 int res1 = 0 ;
11960 bool temp2 = false ;
11961 PyObject * obj0 = 0 ;
11962 PyObject * obj1 = 0 ;
11963 char * kwnames[] = {
11964 (char *) "self",(char *) "extension", NULL
11965 };
11966
11967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11969 if (!SWIG_IsOK(res1)) {
11970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11971 }
11972 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11973 {
11974 arg2 = wxString_in_helper(obj1);
11975 if (arg2 == NULL) SWIG_fail;
11976 temp2 = true;
11977 }
11978 {
11979 PyThreadState* __tstate = wxPyBeginAllowThreads();
11980 (arg1)->SetExtension((wxString const &)*arg2);
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 resultobj = SWIG_Py_Void();
11985 {
11986 if (temp2)
11987 delete arg2;
11988 }
11989 return resultobj;
11990 fail:
11991 {
11992 if (temp2)
11993 delete arg2;
11994 }
11995 return NULL;
11996 }
11997
11998
11999 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12000 PyObject *resultobj = 0;
12001 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12002 long arg2 ;
12003 void *argp1 = 0 ;
12004 int res1 = 0 ;
12005 long val2 ;
12006 int ecode2 = 0 ;
12007 PyObject * obj0 = 0 ;
12008 PyObject * obj1 = 0 ;
12009 char * kwnames[] = {
12010 (char *) "self",(char *) "type", NULL
12011 };
12012
12013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12015 if (!SWIG_IsOK(res1)) {
12016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12017 }
12018 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12019 ecode2 = SWIG_AsVal_long(obj1, &val2);
12020 if (!SWIG_IsOK(ecode2)) {
12021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12022 }
12023 arg2 = static_cast< long >(val2);
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 (arg1)->SetType(arg2);
12027 wxPyEndAllowThreads(__tstate);
12028 if (PyErr_Occurred()) SWIG_fail;
12029 }
12030 resultobj = SWIG_Py_Void();
12031 return resultobj;
12032 fail:
12033 return NULL;
12034 }
12035
12036
12037 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj = 0;
12039 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12040 wxString *arg2 = 0 ;
12041 void *argp1 = 0 ;
12042 int res1 = 0 ;
12043 bool temp2 = false ;
12044 PyObject * obj0 = 0 ;
12045 PyObject * obj1 = 0 ;
12046 char * kwnames[] = {
12047 (char *) "self",(char *) "mimetype", NULL
12048 };
12049
12050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12052 if (!SWIG_IsOK(res1)) {
12053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12054 }
12055 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12056 {
12057 arg2 = wxString_in_helper(obj1);
12058 if (arg2 == NULL) SWIG_fail;
12059 temp2 = true;
12060 }
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 (arg1)->SetMimeType((wxString const &)*arg2);
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 resultobj = SWIG_Py_Void();
12068 {
12069 if (temp2)
12070 delete arg2;
12071 }
12072 return resultobj;
12073 fail:
12074 {
12075 if (temp2)
12076 delete arg2;
12077 }
12078 return NULL;
12079 }
12080
12081
12082 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12083 PyObject *obj;
12084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12085 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12086 return SWIG_Py_Void();
12087 }
12088
12089 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12090 PyObject *resultobj = 0;
12091 wxPyImageHandler *result = 0 ;
12092
12093 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12094 {
12095 PyThreadState* __tstate = wxPyBeginAllowThreads();
12096 result = (wxPyImageHandler *)new wxPyImageHandler();
12097 wxPyEndAllowThreads(__tstate);
12098 if (PyErr_Occurred()) SWIG_fail;
12099 }
12100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12101 return resultobj;
12102 fail:
12103 return NULL;
12104 }
12105
12106
12107 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj = 0;
12109 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12110 PyObject *arg2 = (PyObject *) 0 ;
12111 void *argp1 = 0 ;
12112 int res1 = 0 ;
12113 PyObject * obj0 = 0 ;
12114 PyObject * obj1 = 0 ;
12115 char * kwnames[] = {
12116 (char *) "self",(char *) "self", NULL
12117 };
12118
12119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12121 if (!SWIG_IsOK(res1)) {
12122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12123 }
12124 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12125 arg2 = obj1;
12126 {
12127 PyThreadState* __tstate = wxPyBeginAllowThreads();
12128 (arg1)->_SetSelf(arg2);
12129 wxPyEndAllowThreads(__tstate);
12130 if (PyErr_Occurred()) SWIG_fail;
12131 }
12132 resultobj = SWIG_Py_Void();
12133 return resultobj;
12134 fail:
12135 return NULL;
12136 }
12137
12138
12139 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12140 PyObject *obj;
12141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12142 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12143 return SWIG_Py_Void();
12144 }
12145
12146 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12147 return SWIG_Python_InitShadowInstance(args);
12148 }
12149
12150 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12151 PyObject *resultobj = 0;
12152 wxImageHistogram *result = 0 ;
12153
12154 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (wxImageHistogram *)new wxImageHistogram();
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12162 return resultobj;
12163 fail:
12164 return NULL;
12165 }
12166
12167
12168 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12169 PyObject *resultobj = 0;
12170 byte arg1 ;
12171 byte arg2 ;
12172 byte arg3 ;
12173 unsigned long result;
12174 unsigned char val1 ;
12175 int ecode1 = 0 ;
12176 unsigned char val2 ;
12177 int ecode2 = 0 ;
12178 unsigned char val3 ;
12179 int ecode3 = 0 ;
12180 PyObject * obj0 = 0 ;
12181 PyObject * obj1 = 0 ;
12182 PyObject * obj2 = 0 ;
12183 char * kwnames[] = {
12184 (char *) "r",(char *) "g",(char *) "b", NULL
12185 };
12186
12187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12188 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12189 if (!SWIG_IsOK(ecode1)) {
12190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12191 }
12192 arg1 = static_cast< byte >(val1);
12193 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12194 if (!SWIG_IsOK(ecode2)) {
12195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12196 }
12197 arg2 = static_cast< byte >(val2);
12198 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12199 if (!SWIG_IsOK(ecode3)) {
12200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12201 }
12202 arg3 = static_cast< byte >(val3);
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj = 0;
12218 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12219 byte *arg2 = (byte *) 0 ;
12220 byte *arg3 = (byte *) 0 ;
12221 byte *arg4 = (byte *) 0 ;
12222 byte arg5 = (byte) 1 ;
12223 byte arg6 = (byte) 0 ;
12224 byte arg7 = (byte) 0 ;
12225 bool result;
12226 void *argp1 = 0 ;
12227 int res1 = 0 ;
12228 byte temp2 ;
12229 int res2 = SWIG_TMPOBJ ;
12230 byte temp3 ;
12231 int res3 = SWIG_TMPOBJ ;
12232 byte temp4 ;
12233 int res4 = SWIG_TMPOBJ ;
12234 unsigned char val5 ;
12235 int ecode5 = 0 ;
12236 unsigned char val6 ;
12237 int ecode6 = 0 ;
12238 unsigned char val7 ;
12239 int ecode7 = 0 ;
12240 PyObject * obj0 = 0 ;
12241 PyObject * obj1 = 0 ;
12242 PyObject * obj2 = 0 ;
12243 PyObject * obj3 = 0 ;
12244 char * kwnames[] = {
12245 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12246 };
12247
12248 arg2 = &temp2;
12249 arg3 = &temp3;
12250 arg4 = &temp4;
12251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12253 if (!SWIG_IsOK(res1)) {
12254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12255 }
12256 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12257 if (obj1) {
12258 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12259 if (!SWIG_IsOK(ecode5)) {
12260 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12261 }
12262 arg5 = static_cast< byte >(val5);
12263 }
12264 if (obj2) {
12265 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12266 if (!SWIG_IsOK(ecode6)) {
12267 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12268 }
12269 arg6 = static_cast< byte >(val6);
12270 }
12271 if (obj3) {
12272 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12273 if (!SWIG_IsOK(ecode7)) {
12274 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12275 }
12276 arg7 = static_cast< byte >(val7);
12277 }
12278 {
12279 PyThreadState* __tstate = wxPyBeginAllowThreads();
12280 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 {
12285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12286 }
12287 if (SWIG_IsTmpObj(res2)) {
12288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12289 } else {
12290 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12292 }
12293 if (SWIG_IsTmpObj(res3)) {
12294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12295 } else {
12296 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12298 }
12299 if (SWIG_IsTmpObj(res4)) {
12300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12301 } else {
12302 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12304 }
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj = 0;
12313 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12314 unsigned long arg2 ;
12315 unsigned long result;
12316 void *argp1 = 0 ;
12317 int res1 = 0 ;
12318 unsigned long val2 ;
12319 int ecode2 = 0 ;
12320 PyObject * obj0 = 0 ;
12321 PyObject * obj1 = 0 ;
12322 char * kwnames[] = {
12323 (char *) "self",(char *) "key", NULL
12324 };
12325
12326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12328 if (!SWIG_IsOK(res1)) {
12329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12330 }
12331 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12332 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12333 if (!SWIG_IsOK(ecode2)) {
12334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12335 }
12336 arg2 = static_cast< unsigned long >(val2);
12337 {
12338 PyThreadState* __tstate = wxPyBeginAllowThreads();
12339 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12340 wxPyEndAllowThreads(__tstate);
12341 if (PyErr_Occurred()) SWIG_fail;
12342 }
12343 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12344 return resultobj;
12345 fail:
12346 return NULL;
12347 }
12348
12349
12350 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12351 PyObject *resultobj = 0;
12352 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12353 byte arg2 ;
12354 byte arg3 ;
12355 byte arg4 ;
12356 unsigned long result;
12357 void *argp1 = 0 ;
12358 int res1 = 0 ;
12359 unsigned char val2 ;
12360 int ecode2 = 0 ;
12361 unsigned char val3 ;
12362 int ecode3 = 0 ;
12363 unsigned char val4 ;
12364 int ecode4 = 0 ;
12365 PyObject * obj0 = 0 ;
12366 PyObject * obj1 = 0 ;
12367 PyObject * obj2 = 0 ;
12368 PyObject * obj3 = 0 ;
12369 char * kwnames[] = {
12370 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12371 };
12372
12373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12377 }
12378 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12379 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12380 if (!SWIG_IsOK(ecode2)) {
12381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12382 }
12383 arg2 = static_cast< byte >(val2);
12384 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12385 if (!SWIG_IsOK(ecode3)) {
12386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12387 }
12388 arg3 = static_cast< byte >(val3);
12389 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12390 if (!SWIG_IsOK(ecode4)) {
12391 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12392 }
12393 arg4 = static_cast< byte >(val4);
12394 {
12395 PyThreadState* __tstate = wxPyBeginAllowThreads();
12396 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12397 wxPyEndAllowThreads(__tstate);
12398 if (PyErr_Occurred()) SWIG_fail;
12399 }
12400 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj = 0;
12409 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12410 wxColour *arg2 = 0 ;
12411 unsigned long result;
12412 void *argp1 = 0 ;
12413 int res1 = 0 ;
12414 wxColour temp2 ;
12415 PyObject * obj0 = 0 ;
12416 PyObject * obj1 = 0 ;
12417 char * kwnames[] = {
12418 (char *) "self",(char *) "colour", NULL
12419 };
12420
12421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12423 if (!SWIG_IsOK(res1)) {
12424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12425 }
12426 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12427 {
12428 arg2 = &temp2;
12429 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12430 }
12431 {
12432 PyThreadState* __tstate = wxPyBeginAllowThreads();
12433 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12434 wxPyEndAllowThreads(__tstate);
12435 if (PyErr_Occurred()) SWIG_fail;
12436 }
12437 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12438 return resultobj;
12439 fail:
12440 return NULL;
12441 }
12442
12443
12444 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12445 PyObject *obj;
12446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12447 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12448 return SWIG_Py_Void();
12449 }
12450
12451 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12452 return SWIG_Python_InitShadowInstance(args);
12453 }
12454
12455 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj = 0;
12457 byte arg1 = (byte) 0 ;
12458 byte arg2 = (byte) 0 ;
12459 byte arg3 = (byte) 0 ;
12460 wxImage_RGBValue *result = 0 ;
12461 unsigned char val1 ;
12462 int ecode1 = 0 ;
12463 unsigned char val2 ;
12464 int ecode2 = 0 ;
12465 unsigned char val3 ;
12466 int ecode3 = 0 ;
12467 PyObject * obj0 = 0 ;
12468 PyObject * obj1 = 0 ;
12469 PyObject * obj2 = 0 ;
12470 char * kwnames[] = {
12471 (char *) "r",(char *) "g",(char *) "b", NULL
12472 };
12473
12474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12475 if (obj0) {
12476 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12477 if (!SWIG_IsOK(ecode1)) {
12478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12479 }
12480 arg1 = static_cast< byte >(val1);
12481 }
12482 if (obj1) {
12483 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12484 if (!SWIG_IsOK(ecode2)) {
12485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12486 }
12487 arg2 = static_cast< byte >(val2);
12488 }
12489 if (obj2) {
12490 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12491 if (!SWIG_IsOK(ecode3)) {
12492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12493 }
12494 arg3 = static_cast< byte >(val3);
12495 }
12496 {
12497 PyThreadState* __tstate = wxPyBeginAllowThreads();
12498 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12499 wxPyEndAllowThreads(__tstate);
12500 if (PyErr_Occurred()) SWIG_fail;
12501 }
12502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12503 return resultobj;
12504 fail:
12505 return NULL;
12506 }
12507
12508
12509 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12510 PyObject *resultobj = 0;
12511 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12512 byte arg2 ;
12513 void *argp1 = 0 ;
12514 int res1 = 0 ;
12515 unsigned char val2 ;
12516 int ecode2 = 0 ;
12517 PyObject *swig_obj[2] ;
12518
12519 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12521 if (!SWIG_IsOK(res1)) {
12522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12523 }
12524 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12525 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12526 if (!SWIG_IsOK(ecode2)) {
12527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12528 }
12529 arg2 = static_cast< byte >(val2);
12530 if (arg1) (arg1)->red = arg2;
12531
12532 resultobj = SWIG_Py_Void();
12533 return resultobj;
12534 fail:
12535 return NULL;
12536 }
12537
12538
12539 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12540 PyObject *resultobj = 0;
12541 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12542 byte result;
12543 void *argp1 = 0 ;
12544 int res1 = 0 ;
12545 PyObject *swig_obj[1] ;
12546
12547 if (!args) SWIG_fail;
12548 swig_obj[0] = args;
12549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12550 if (!SWIG_IsOK(res1)) {
12551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12552 }
12553 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12554 result = (byte) ((arg1)->red);
12555 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12563 PyObject *resultobj = 0;
12564 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12565 byte arg2 ;
12566 void *argp1 = 0 ;
12567 int res1 = 0 ;
12568 unsigned char val2 ;
12569 int ecode2 = 0 ;
12570 PyObject *swig_obj[2] ;
12571
12572 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12574 if (!SWIG_IsOK(res1)) {
12575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12576 }
12577 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12578 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12579 if (!SWIG_IsOK(ecode2)) {
12580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12581 }
12582 arg2 = static_cast< byte >(val2);
12583 if (arg1) (arg1)->green = arg2;
12584
12585 resultobj = SWIG_Py_Void();
12586 return resultobj;
12587 fail:
12588 return NULL;
12589 }
12590
12591
12592 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12593 PyObject *resultobj = 0;
12594 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12595 byte result;
12596 void *argp1 = 0 ;
12597 int res1 = 0 ;
12598 PyObject *swig_obj[1] ;
12599
12600 if (!args) SWIG_fail;
12601 swig_obj[0] = args;
12602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12603 if (!SWIG_IsOK(res1)) {
12604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12605 }
12606 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12607 result = (byte) ((arg1)->green);
12608 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12609 return resultobj;
12610 fail:
12611 return NULL;
12612 }
12613
12614
12615 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12616 PyObject *resultobj = 0;
12617 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12618 byte arg2 ;
12619 void *argp1 = 0 ;
12620 int res1 = 0 ;
12621 unsigned char val2 ;
12622 int ecode2 = 0 ;
12623 PyObject *swig_obj[2] ;
12624
12625 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12627 if (!SWIG_IsOK(res1)) {
12628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12629 }
12630 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12631 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12632 if (!SWIG_IsOK(ecode2)) {
12633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12634 }
12635 arg2 = static_cast< byte >(val2);
12636 if (arg1) (arg1)->blue = arg2;
12637
12638 resultobj = SWIG_Py_Void();
12639 return resultobj;
12640 fail:
12641 return NULL;
12642 }
12643
12644
12645 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12646 PyObject *resultobj = 0;
12647 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12648 byte result;
12649 void *argp1 = 0 ;
12650 int res1 = 0 ;
12651 PyObject *swig_obj[1] ;
12652
12653 if (!args) SWIG_fail;
12654 swig_obj[0] = args;
12655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12656 if (!SWIG_IsOK(res1)) {
12657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12658 }
12659 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12660 result = (byte) ((arg1)->blue);
12661 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12662 return resultobj;
12663 fail:
12664 return NULL;
12665 }
12666
12667
12668 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12669 PyObject *obj;
12670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12671 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12672 return SWIG_Py_Void();
12673 }
12674
12675 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12676 return SWIG_Python_InitShadowInstance(args);
12677 }
12678
12679 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj = 0;
12681 double arg1 = (double) 0.0 ;
12682 double arg2 = (double) 0.0 ;
12683 double arg3 = (double) 0.0 ;
12684 wxImage_HSVValue *result = 0 ;
12685 double val1 ;
12686 int ecode1 = 0 ;
12687 double val2 ;
12688 int ecode2 = 0 ;
12689 double val3 ;
12690 int ecode3 = 0 ;
12691 PyObject * obj0 = 0 ;
12692 PyObject * obj1 = 0 ;
12693 PyObject * obj2 = 0 ;
12694 char * kwnames[] = {
12695 (char *) "h",(char *) "s",(char *) "v", NULL
12696 };
12697
12698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12699 if (obj0) {
12700 ecode1 = SWIG_AsVal_double(obj0, &val1);
12701 if (!SWIG_IsOK(ecode1)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12703 }
12704 arg1 = static_cast< double >(val1);
12705 }
12706 if (obj1) {
12707 ecode2 = SWIG_AsVal_double(obj1, &val2);
12708 if (!SWIG_IsOK(ecode2)) {
12709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12710 }
12711 arg2 = static_cast< double >(val2);
12712 }
12713 if (obj2) {
12714 ecode3 = SWIG_AsVal_double(obj2, &val3);
12715 if (!SWIG_IsOK(ecode3)) {
12716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12717 }
12718 arg3 = static_cast< double >(val3);
12719 }
12720 {
12721 PyThreadState* __tstate = wxPyBeginAllowThreads();
12722 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734 PyObject *resultobj = 0;
12735 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12736 double arg2 ;
12737 void *argp1 = 0 ;
12738 int res1 = 0 ;
12739 double val2 ;
12740 int ecode2 = 0 ;
12741 PyObject *swig_obj[2] ;
12742
12743 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12745 if (!SWIG_IsOK(res1)) {
12746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12747 }
12748 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12749 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12750 if (!SWIG_IsOK(ecode2)) {
12751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12752 }
12753 arg2 = static_cast< double >(val2);
12754 if (arg1) (arg1)->hue = arg2;
12755
12756 resultobj = SWIG_Py_Void();
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12764 PyObject *resultobj = 0;
12765 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12766 double result;
12767 void *argp1 = 0 ;
12768 int res1 = 0 ;
12769 PyObject *swig_obj[1] ;
12770
12771 if (!args) SWIG_fail;
12772 swig_obj[0] = args;
12773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12774 if (!SWIG_IsOK(res1)) {
12775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12776 }
12777 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12778 result = (double) ((arg1)->hue);
12779 resultobj = SWIG_From_double(static_cast< double >(result));
12780 return resultobj;
12781 fail:
12782 return NULL;
12783 }
12784
12785
12786 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12787 PyObject *resultobj = 0;
12788 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12789 double arg2 ;
12790 void *argp1 = 0 ;
12791 int res1 = 0 ;
12792 double val2 ;
12793 int ecode2 = 0 ;
12794 PyObject *swig_obj[2] ;
12795
12796 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12798 if (!SWIG_IsOK(res1)) {
12799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12800 }
12801 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12802 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12803 if (!SWIG_IsOK(ecode2)) {
12804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12805 }
12806 arg2 = static_cast< double >(val2);
12807 if (arg1) (arg1)->saturation = arg2;
12808
12809 resultobj = SWIG_Py_Void();
12810 return resultobj;
12811 fail:
12812 return NULL;
12813 }
12814
12815
12816 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12817 PyObject *resultobj = 0;
12818 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12819 double result;
12820 void *argp1 = 0 ;
12821 int res1 = 0 ;
12822 PyObject *swig_obj[1] ;
12823
12824 if (!args) SWIG_fail;
12825 swig_obj[0] = args;
12826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12827 if (!SWIG_IsOK(res1)) {
12828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12829 }
12830 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12831 result = (double) ((arg1)->saturation);
12832 resultobj = SWIG_From_double(static_cast< double >(result));
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12840 PyObject *resultobj = 0;
12841 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12842 double arg2 ;
12843 void *argp1 = 0 ;
12844 int res1 = 0 ;
12845 double val2 ;
12846 int ecode2 = 0 ;
12847 PyObject *swig_obj[2] ;
12848
12849 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12851 if (!SWIG_IsOK(res1)) {
12852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12853 }
12854 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12855 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12856 if (!SWIG_IsOK(ecode2)) {
12857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12858 }
12859 arg2 = static_cast< double >(val2);
12860 if (arg1) (arg1)->value = arg2;
12861
12862 resultobj = SWIG_Py_Void();
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12870 PyObject *resultobj = 0;
12871 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12872 double result;
12873 void *argp1 = 0 ;
12874 int res1 = 0 ;
12875 PyObject *swig_obj[1] ;
12876
12877 if (!args) SWIG_fail;
12878 swig_obj[0] = args;
12879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12880 if (!SWIG_IsOK(res1)) {
12881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12882 }
12883 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12884 result = (double) ((arg1)->value);
12885 resultobj = SWIG_From_double(static_cast< double >(result));
12886 return resultobj;
12887 fail:
12888 return NULL;
12889 }
12890
12891
12892 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12893 PyObject *obj;
12894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12895 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12896 return SWIG_Py_Void();
12897 }
12898
12899 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12900 return SWIG_Python_InitShadowInstance(args);
12901 }
12902
12903 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12904 PyObject *resultobj = 0;
12905 wxString *arg1 = 0 ;
12906 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12907 int arg3 = (int) -1 ;
12908 wxImage *result = 0 ;
12909 bool temp1 = false ;
12910 long val2 ;
12911 int ecode2 = 0 ;
12912 int val3 ;
12913 int ecode3 = 0 ;
12914 PyObject * obj0 = 0 ;
12915 PyObject * obj1 = 0 ;
12916 PyObject * obj2 = 0 ;
12917 char * kwnames[] = {
12918 (char *) "name",(char *) "type",(char *) "index", NULL
12919 };
12920
12921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12922 {
12923 arg1 = wxString_in_helper(obj0);
12924 if (arg1 == NULL) SWIG_fail;
12925 temp1 = true;
12926 }
12927 if (obj1) {
12928 ecode2 = SWIG_AsVal_long(obj1, &val2);
12929 if (!SWIG_IsOK(ecode2)) {
12930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12931 }
12932 arg2 = static_cast< long >(val2);
12933 }
12934 if (obj2) {
12935 ecode3 = SWIG_AsVal_int(obj2, &val3);
12936 if (!SWIG_IsOK(ecode3)) {
12937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12938 }
12939 arg3 = static_cast< int >(val3);
12940 }
12941 {
12942 PyThreadState* __tstate = wxPyBeginAllowThreads();
12943 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12948 {
12949 if (temp1)
12950 delete arg1;
12951 }
12952 return resultobj;
12953 fail:
12954 {
12955 if (temp1)
12956 delete arg1;
12957 }
12958 return NULL;
12959 }
12960
12961
12962 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12963 PyObject *resultobj = 0;
12964 wxImage *arg1 = (wxImage *) 0 ;
12965 void *argp1 = 0 ;
12966 int res1 = 0 ;
12967 PyObject *swig_obj[1] ;
12968
12969 if (!args) SWIG_fail;
12970 swig_obj[0] = args;
12971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12972 if (!SWIG_IsOK(res1)) {
12973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12974 }
12975 arg1 = reinterpret_cast< wxImage * >(argp1);
12976 {
12977 PyThreadState* __tstate = wxPyBeginAllowThreads();
12978 delete arg1;
12979
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 resultobj = SWIG_Py_Void();
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12991 PyObject *resultobj = 0;
12992 wxString *arg1 = 0 ;
12993 wxString *arg2 = 0 ;
12994 int arg3 = (int) -1 ;
12995 wxImage *result = 0 ;
12996 bool temp1 = false ;
12997 bool temp2 = false ;
12998 int val3 ;
12999 int ecode3 = 0 ;
13000 PyObject * obj0 = 0 ;
13001 PyObject * obj1 = 0 ;
13002 PyObject * obj2 = 0 ;
13003 char * kwnames[] = {
13004 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13005 };
13006
13007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13008 {
13009 arg1 = wxString_in_helper(obj0);
13010 if (arg1 == NULL) SWIG_fail;
13011 temp1 = true;
13012 }
13013 {
13014 arg2 = wxString_in_helper(obj1);
13015 if (arg2 == NULL) SWIG_fail;
13016 temp2 = true;
13017 }
13018 if (obj2) {
13019 ecode3 = SWIG_AsVal_int(obj2, &val3);
13020 if (!SWIG_IsOK(ecode3)) {
13021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13022 }
13023 arg3 = static_cast< int >(val3);
13024 }
13025 {
13026 PyThreadState* __tstate = wxPyBeginAllowThreads();
13027 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13028 wxPyEndAllowThreads(__tstate);
13029 if (PyErr_Occurred()) SWIG_fail;
13030 }
13031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13032 {
13033 if (temp1)
13034 delete arg1;
13035 }
13036 {
13037 if (temp2)
13038 delete arg2;
13039 }
13040 return resultobj;
13041 fail:
13042 {
13043 if (temp1)
13044 delete arg1;
13045 }
13046 {
13047 if (temp2)
13048 delete arg2;
13049 }
13050 return NULL;
13051 }
13052
13053
13054 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj = 0;
13056 wxInputStream *arg1 = 0 ;
13057 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13058 int arg3 = (int) -1 ;
13059 wxImage *result = 0 ;
13060 wxPyInputStream *temp1 ;
13061 bool created1 ;
13062 long val2 ;
13063 int ecode2 = 0 ;
13064 int val3 ;
13065 int ecode3 = 0 ;
13066 PyObject * obj0 = 0 ;
13067 PyObject * obj1 = 0 ;
13068 PyObject * obj2 = 0 ;
13069 char * kwnames[] = {
13070 (char *) "stream",(char *) "type",(char *) "index", NULL
13071 };
13072
13073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13074 {
13075 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13076 arg1 = temp1->m_wxis;
13077 created1 = false;
13078 } else {
13079 PyErr_Clear(); // clear the failure of the wxPyConvert above
13080 arg1 = wxPyCBInputStream_create(obj0, false);
13081 if (arg1 == NULL) {
13082 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13083 SWIG_fail;
13084 }
13085 created1 = true;
13086 }
13087 }
13088 if (obj1) {
13089 ecode2 = SWIG_AsVal_long(obj1, &val2);
13090 if (!SWIG_IsOK(ecode2)) {
13091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13092 }
13093 arg2 = static_cast< long >(val2);
13094 }
13095 if (obj2) {
13096 ecode3 = SWIG_AsVal_int(obj2, &val3);
13097 if (!SWIG_IsOK(ecode3)) {
13098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13099 }
13100 arg3 = static_cast< int >(val3);
13101 }
13102 {
13103 PyThreadState* __tstate = wxPyBeginAllowThreads();
13104 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13105 wxPyEndAllowThreads(__tstate);
13106 if (PyErr_Occurred()) SWIG_fail;
13107 }
13108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13109 {
13110 if (created1) delete arg1;
13111 }
13112 return resultobj;
13113 fail:
13114 {
13115 if (created1) delete arg1;
13116 }
13117 return NULL;
13118 }
13119
13120
13121 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13122 PyObject *resultobj = 0;
13123 wxInputStream *arg1 = 0 ;
13124 wxString *arg2 = 0 ;
13125 int arg3 = (int) -1 ;
13126 wxImage *result = 0 ;
13127 wxPyInputStream *temp1 ;
13128 bool created1 ;
13129 bool temp2 = false ;
13130 int val3 ;
13131 int ecode3 = 0 ;
13132 PyObject * obj0 = 0 ;
13133 PyObject * obj1 = 0 ;
13134 PyObject * obj2 = 0 ;
13135 char * kwnames[] = {
13136 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13137 };
13138
13139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13140 {
13141 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13142 arg1 = temp1->m_wxis;
13143 created1 = false;
13144 } else {
13145 PyErr_Clear(); // clear the failure of the wxPyConvert above
13146 arg1 = wxPyCBInputStream_create(obj0, false);
13147 if (arg1 == NULL) {
13148 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13149 SWIG_fail;
13150 }
13151 created1 = true;
13152 }
13153 }
13154 {
13155 arg2 = wxString_in_helper(obj1);
13156 if (arg2 == NULL) SWIG_fail;
13157 temp2 = true;
13158 }
13159 if (obj2) {
13160 ecode3 = SWIG_AsVal_int(obj2, &val3);
13161 if (!SWIG_IsOK(ecode3)) {
13162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13163 }
13164 arg3 = static_cast< int >(val3);
13165 }
13166 {
13167 PyThreadState* __tstate = wxPyBeginAllowThreads();
13168 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13173 {
13174 if (created1) delete arg1;
13175 }
13176 {
13177 if (temp2)
13178 delete arg2;
13179 }
13180 return resultobj;
13181 fail:
13182 {
13183 if (created1) delete arg1;
13184 }
13185 {
13186 if (temp2)
13187 delete arg2;
13188 }
13189 return NULL;
13190 }
13191
13192
13193 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13194 PyObject *resultobj = 0;
13195 int arg1 = (int) 0 ;
13196 int arg2 = (int) 0 ;
13197 bool arg3 = (bool) true ;
13198 wxImage *result = 0 ;
13199 int val1 ;
13200 int ecode1 = 0 ;
13201 int val2 ;
13202 int ecode2 = 0 ;
13203 bool val3 ;
13204 int ecode3 = 0 ;
13205 PyObject * obj0 = 0 ;
13206 PyObject * obj1 = 0 ;
13207 PyObject * obj2 = 0 ;
13208 char * kwnames[] = {
13209 (char *) "width",(char *) "height",(char *) "clear", NULL
13210 };
13211
13212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13213 if (obj0) {
13214 ecode1 = SWIG_AsVal_int(obj0, &val1);
13215 if (!SWIG_IsOK(ecode1)) {
13216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13217 }
13218 arg1 = static_cast< int >(val1);
13219 }
13220 if (obj1) {
13221 ecode2 = SWIG_AsVal_int(obj1, &val2);
13222 if (!SWIG_IsOK(ecode2)) {
13223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13224 }
13225 arg2 = static_cast< int >(val2);
13226 }
13227 if (obj2) {
13228 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13229 if (!SWIG_IsOK(ecode3)) {
13230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13231 }
13232 arg3 = static_cast< bool >(val3);
13233 }
13234 {
13235 PyThreadState* __tstate = wxPyBeginAllowThreads();
13236 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13237 wxPyEndAllowThreads(__tstate);
13238 if (PyErr_Occurred()) SWIG_fail;
13239 }
13240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13241 return resultobj;
13242 fail:
13243 return NULL;
13244 }
13245
13246
13247 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13248 PyObject *resultobj = 0;
13249 wxBitmap *arg1 = 0 ;
13250 wxImage *result = 0 ;
13251 void *argp1 = 0 ;
13252 int res1 = 0 ;
13253 PyObject * obj0 = 0 ;
13254 char * kwnames[] = {
13255 (char *) "bitmap", NULL
13256 };
13257
13258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13259 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13260 if (!SWIG_IsOK(res1)) {
13261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13262 }
13263 if (!argp1) {
13264 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13265 }
13266 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13267 {
13268 if (!wxPyCheckForApp()) SWIG_fail;
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13275 return resultobj;
13276 fail:
13277 return NULL;
13278 }
13279
13280
13281 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13282 PyObject *resultobj = 0;
13283 int arg1 ;
13284 int arg2 ;
13285 buffer arg3 ;
13286 int arg4 ;
13287 wxImage *result = 0 ;
13288 int val1 ;
13289 int ecode1 = 0 ;
13290 int val2 ;
13291 int ecode2 = 0 ;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 PyObject * obj2 = 0 ;
13295 char * kwnames[] = {
13296 (char *) "width",(char *) "height",(char *) "data", NULL
13297 };
13298
13299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13300 ecode1 = SWIG_AsVal_int(obj0, &val1);
13301 if (!SWIG_IsOK(ecode1)) {
13302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13303 }
13304 arg1 = static_cast< int >(val1);
13305 ecode2 = SWIG_AsVal_int(obj1, &val2);
13306 if (!SWIG_IsOK(ecode2)) {
13307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13308 }
13309 arg2 = static_cast< int >(val2);
13310 {
13311 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13312 }
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13316 wxPyEndAllowThreads(__tstate);
13317 if (PyErr_Occurred()) SWIG_fail;
13318 }
13319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13320 return resultobj;
13321 fail:
13322 return NULL;
13323 }
13324
13325
13326 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13327 PyObject *resultobj = 0;
13328 int arg1 ;
13329 int arg2 ;
13330 buffer arg3 ;
13331 int arg4 ;
13332 buffer arg5 ;
13333 int arg6 ;
13334 wxImage *result = 0 ;
13335 int val1 ;
13336 int ecode1 = 0 ;
13337 int val2 ;
13338 int ecode2 = 0 ;
13339 PyObject * obj0 = 0 ;
13340 PyObject * obj1 = 0 ;
13341 PyObject * obj2 = 0 ;
13342 PyObject * obj3 = 0 ;
13343 char * kwnames[] = {
13344 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13345 };
13346
13347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13348 ecode1 = SWIG_AsVal_int(obj0, &val1);
13349 if (!SWIG_IsOK(ecode1)) {
13350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13351 }
13352 arg1 = static_cast< int >(val1);
13353 ecode2 = SWIG_AsVal_int(obj1, &val2);
13354 if (!SWIG_IsOK(ecode2)) {
13355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13356 }
13357 arg2 = static_cast< int >(val2);
13358 {
13359 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13360 }
13361 {
13362 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13363 }
13364 {
13365 PyThreadState* __tstate = wxPyBeginAllowThreads();
13366 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13367 wxPyEndAllowThreads(__tstate);
13368 if (PyErr_Occurred()) SWIG_fail;
13369 }
13370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13371 return resultobj;
13372 fail:
13373 return NULL;
13374 }
13375
13376
13377 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13378 PyObject *resultobj = 0;
13379 wxImage *arg1 = (wxImage *) 0 ;
13380 int arg2 ;
13381 int arg3 ;
13382 bool arg4 = (bool) true ;
13383 void *argp1 = 0 ;
13384 int res1 = 0 ;
13385 int val2 ;
13386 int ecode2 = 0 ;
13387 int val3 ;
13388 int ecode3 = 0 ;
13389 bool val4 ;
13390 int ecode4 = 0 ;
13391 PyObject * obj0 = 0 ;
13392 PyObject * obj1 = 0 ;
13393 PyObject * obj2 = 0 ;
13394 PyObject * obj3 = 0 ;
13395 char * kwnames[] = {
13396 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13397 };
13398
13399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13403 }
13404 arg1 = reinterpret_cast< wxImage * >(argp1);
13405 ecode2 = SWIG_AsVal_int(obj1, &val2);
13406 if (!SWIG_IsOK(ecode2)) {
13407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13408 }
13409 arg2 = static_cast< int >(val2);
13410 ecode3 = SWIG_AsVal_int(obj2, &val3);
13411 if (!SWIG_IsOK(ecode3)) {
13412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13413 }
13414 arg3 = static_cast< int >(val3);
13415 if (obj3) {
13416 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13417 if (!SWIG_IsOK(ecode4)) {
13418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13419 }
13420 arg4 = static_cast< bool >(val4);
13421 }
13422 {
13423 PyThreadState* __tstate = wxPyBeginAllowThreads();
13424 (arg1)->Create(arg2,arg3,arg4);
13425 wxPyEndAllowThreads(__tstate);
13426 if (PyErr_Occurred()) SWIG_fail;
13427 }
13428 resultobj = SWIG_Py_Void();
13429 return resultobj;
13430 fail:
13431 return NULL;
13432 }
13433
13434
13435 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13436 PyObject *resultobj = 0;
13437 wxImage *arg1 = (wxImage *) 0 ;
13438 void *argp1 = 0 ;
13439 int res1 = 0 ;
13440 PyObject *swig_obj[1] ;
13441
13442 if (!args) SWIG_fail;
13443 swig_obj[0] = args;
13444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13445 if (!SWIG_IsOK(res1)) {
13446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13447 }
13448 arg1 = reinterpret_cast< wxImage * >(argp1);
13449 {
13450 PyThreadState* __tstate = wxPyBeginAllowThreads();
13451 (arg1)->Destroy();
13452 wxPyEndAllowThreads(__tstate);
13453 if (PyErr_Occurred()) SWIG_fail;
13454 }
13455 resultobj = SWIG_Py_Void();
13456 return resultobj;
13457 fail:
13458 return NULL;
13459 }
13460
13461
13462 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj = 0;
13464 wxImage *arg1 = (wxImage *) 0 ;
13465 int arg2 ;
13466 int arg3 ;
13467 SwigValueWrapper<wxImage > result;
13468 void *argp1 = 0 ;
13469 int res1 = 0 ;
13470 int val2 ;
13471 int ecode2 = 0 ;
13472 int val3 ;
13473 int ecode3 = 0 ;
13474 PyObject * obj0 = 0 ;
13475 PyObject * obj1 = 0 ;
13476 PyObject * obj2 = 0 ;
13477 char * kwnames[] = {
13478 (char *) "self",(char *) "width",(char *) "height", NULL
13479 };
13480
13481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13483 if (!SWIG_IsOK(res1)) {
13484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13485 }
13486 arg1 = reinterpret_cast< wxImage * >(argp1);
13487 ecode2 = SWIG_AsVal_int(obj1, &val2);
13488 if (!SWIG_IsOK(ecode2)) {
13489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13490 }
13491 arg2 = static_cast< int >(val2);
13492 ecode3 = SWIG_AsVal_int(obj2, &val3);
13493 if (!SWIG_IsOK(ecode3)) {
13494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13495 }
13496 arg3 = static_cast< int >(val3);
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = (arg1)->Scale(arg2,arg3);
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13504 return resultobj;
13505 fail:
13506 return NULL;
13507 }
13508
13509
13510 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj = 0;
13512 wxImage *arg1 = (wxImage *) 0 ;
13513 int arg2 ;
13514 int arg3 ;
13515 SwigValueWrapper<wxImage > result;
13516 void *argp1 = 0 ;
13517 int res1 = 0 ;
13518 int val2 ;
13519 int ecode2 = 0 ;
13520 int val3 ;
13521 int ecode3 = 0 ;
13522 PyObject * obj0 = 0 ;
13523 PyObject * obj1 = 0 ;
13524 PyObject * obj2 = 0 ;
13525 char * kwnames[] = {
13526 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13527 };
13528
13529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13531 if (!SWIG_IsOK(res1)) {
13532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13533 }
13534 arg1 = reinterpret_cast< wxImage * >(argp1);
13535 ecode2 = SWIG_AsVal_int(obj1, &val2);
13536 if (!SWIG_IsOK(ecode2)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13538 }
13539 arg2 = static_cast< int >(val2);
13540 ecode3 = SWIG_AsVal_int(obj2, &val3);
13541 if (!SWIG_IsOK(ecode3)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13543 }
13544 arg3 = static_cast< int >(val3);
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj = 0;
13560 wxImage *arg1 = (wxImage *) 0 ;
13561 int arg2 ;
13562 int arg3 ;
13563 wxImage *result = 0 ;
13564 void *argp1 = 0 ;
13565 int res1 = 0 ;
13566 int val2 ;
13567 int ecode2 = 0 ;
13568 int val3 ;
13569 int ecode3 = 0 ;
13570 PyObject * obj0 = 0 ;
13571 PyObject * obj1 = 0 ;
13572 PyObject * obj2 = 0 ;
13573 char * kwnames[] = {
13574 (char *) "self",(char *) "width",(char *) "height", NULL
13575 };
13576
13577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13579 if (!SWIG_IsOK(res1)) {
13580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13581 }
13582 arg1 = reinterpret_cast< wxImage * >(argp1);
13583 ecode2 = SWIG_AsVal_int(obj1, &val2);
13584 if (!SWIG_IsOK(ecode2)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13586 }
13587 arg2 = static_cast< int >(val2);
13588 ecode3 = SWIG_AsVal_int(obj2, &val3);
13589 if (!SWIG_IsOK(ecode3)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13591 }
13592 arg3 = static_cast< int >(val3);
13593 {
13594 PyThreadState* __tstate = wxPyBeginAllowThreads();
13595 {
13596 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13597 result = (wxImage *) &_result_ref;
13598 }
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13603 return resultobj;
13604 fail:
13605 return NULL;
13606 }
13607
13608
13609 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13610 PyObject *resultobj = 0;
13611 wxImage *arg1 = (wxImage *) 0 ;
13612 wxSize *arg2 = 0 ;
13613 wxPoint *arg3 = 0 ;
13614 int arg4 = (int) -1 ;
13615 int arg5 = (int) -1 ;
13616 int arg6 = (int) -1 ;
13617 wxImage *result = 0 ;
13618 void *argp1 = 0 ;
13619 int res1 = 0 ;
13620 wxSize temp2 ;
13621 wxPoint temp3 ;
13622 int val4 ;
13623 int ecode4 = 0 ;
13624 int val5 ;
13625 int ecode5 = 0 ;
13626 int val6 ;
13627 int ecode6 = 0 ;
13628 PyObject * obj0 = 0 ;
13629 PyObject * obj1 = 0 ;
13630 PyObject * obj2 = 0 ;
13631 PyObject * obj3 = 0 ;
13632 PyObject * obj4 = 0 ;
13633 PyObject * obj5 = 0 ;
13634 char * kwnames[] = {
13635 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13636 };
13637
13638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13640 if (!SWIG_IsOK(res1)) {
13641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13642 }
13643 arg1 = reinterpret_cast< wxImage * >(argp1);
13644 {
13645 arg2 = &temp2;
13646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13647 }
13648 {
13649 arg3 = &temp3;
13650 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13651 }
13652 if (obj3) {
13653 ecode4 = SWIG_AsVal_int(obj3, &val4);
13654 if (!SWIG_IsOK(ecode4)) {
13655 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13656 }
13657 arg4 = static_cast< int >(val4);
13658 }
13659 if (obj4) {
13660 ecode5 = SWIG_AsVal_int(obj4, &val5);
13661 if (!SWIG_IsOK(ecode5)) {
13662 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13663 }
13664 arg5 = static_cast< int >(val5);
13665 }
13666 if (obj5) {
13667 ecode6 = SWIG_AsVal_int(obj5, &val6);
13668 if (!SWIG_IsOK(ecode6)) {
13669 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13670 }
13671 arg6 = static_cast< int >(val6);
13672 }
13673 {
13674 PyThreadState* __tstate = wxPyBeginAllowThreads();
13675 {
13676 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13677 result = (wxImage *) &_result_ref;
13678 }
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13683 return resultobj;
13684 fail:
13685 return NULL;
13686 }
13687
13688
13689 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13690 PyObject *resultobj = 0;
13691 wxImage *arg1 = (wxImage *) 0 ;
13692 int arg2 ;
13693 int arg3 ;
13694 byte arg4 ;
13695 byte arg5 ;
13696 byte arg6 ;
13697 void *argp1 = 0 ;
13698 int res1 = 0 ;
13699 int val2 ;
13700 int ecode2 = 0 ;
13701 int val3 ;
13702 int ecode3 = 0 ;
13703 unsigned char val4 ;
13704 int ecode4 = 0 ;
13705 unsigned char val5 ;
13706 int ecode5 = 0 ;
13707 unsigned char val6 ;
13708 int ecode6 = 0 ;
13709 PyObject * obj0 = 0 ;
13710 PyObject * obj1 = 0 ;
13711 PyObject * obj2 = 0 ;
13712 PyObject * obj3 = 0 ;
13713 PyObject * obj4 = 0 ;
13714 PyObject * obj5 = 0 ;
13715 char * kwnames[] = {
13716 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13717 };
13718
13719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13721 if (!SWIG_IsOK(res1)) {
13722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13723 }
13724 arg1 = reinterpret_cast< wxImage * >(argp1);
13725 ecode2 = SWIG_AsVal_int(obj1, &val2);
13726 if (!SWIG_IsOK(ecode2)) {
13727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13728 }
13729 arg2 = static_cast< int >(val2);
13730 ecode3 = SWIG_AsVal_int(obj2, &val3);
13731 if (!SWIG_IsOK(ecode3)) {
13732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13733 }
13734 arg3 = static_cast< int >(val3);
13735 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13736 if (!SWIG_IsOK(ecode4)) {
13737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13738 }
13739 arg4 = static_cast< byte >(val4);
13740 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13741 if (!SWIG_IsOK(ecode5)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13743 }
13744 arg5 = static_cast< byte >(val5);
13745 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13746 if (!SWIG_IsOK(ecode6)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13748 }
13749 arg6 = static_cast< byte >(val6);
13750 {
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 resultobj = SWIG_Py_Void();
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj = 0;
13765 wxImage *arg1 = (wxImage *) 0 ;
13766 wxRect *arg2 = 0 ;
13767 byte arg3 ;
13768 byte arg4 ;
13769 byte arg5 ;
13770 void *argp1 = 0 ;
13771 int res1 = 0 ;
13772 wxRect temp2 ;
13773 unsigned char val3 ;
13774 int ecode3 = 0 ;
13775 unsigned char val4 ;
13776 int ecode4 = 0 ;
13777 unsigned char val5 ;
13778 int ecode5 = 0 ;
13779 PyObject * obj0 = 0 ;
13780 PyObject * obj1 = 0 ;
13781 PyObject * obj2 = 0 ;
13782 PyObject * obj3 = 0 ;
13783 PyObject * obj4 = 0 ;
13784 char * kwnames[] = {
13785 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13786 };
13787
13788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13790 if (!SWIG_IsOK(res1)) {
13791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13792 }
13793 arg1 = reinterpret_cast< wxImage * >(argp1);
13794 {
13795 arg2 = &temp2;
13796 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13797 }
13798 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13799 if (!SWIG_IsOK(ecode3)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13801 }
13802 arg3 = static_cast< byte >(val3);
13803 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13804 if (!SWIG_IsOK(ecode4)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13806 }
13807 arg4 = static_cast< byte >(val4);
13808 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13809 if (!SWIG_IsOK(ecode5)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13811 }
13812 arg5 = static_cast< byte >(val5);
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_Py_Void();
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxImage *arg1 = (wxImage *) 0 ;
13829 int arg2 ;
13830 int arg3 ;
13831 byte result;
13832 void *argp1 = 0 ;
13833 int res1 = 0 ;
13834 int val2 ;
13835 int ecode2 = 0 ;
13836 int val3 ;
13837 int ecode3 = 0 ;
13838 PyObject * obj0 = 0 ;
13839 PyObject * obj1 = 0 ;
13840 PyObject * obj2 = 0 ;
13841 char * kwnames[] = {
13842 (char *) "self",(char *) "x",(char *) "y", NULL
13843 };
13844
13845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13847 if (!SWIG_IsOK(res1)) {
13848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13849 }
13850 arg1 = reinterpret_cast< wxImage * >(argp1);
13851 ecode2 = SWIG_AsVal_int(obj1, &val2);
13852 if (!SWIG_IsOK(ecode2)) {
13853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13854 }
13855 arg2 = static_cast< int >(val2);
13856 ecode3 = SWIG_AsVal_int(obj2, &val3);
13857 if (!SWIG_IsOK(ecode3)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13859 }
13860 arg3 = static_cast< int >(val3);
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 result = (byte)(arg1)->GetRed(arg2,arg3);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 wxImage *arg1 = (wxImage *) 0 ;
13877 int arg2 ;
13878 int arg3 ;
13879 byte result;
13880 void *argp1 = 0 ;
13881 int res1 = 0 ;
13882 int val2 ;
13883 int ecode2 = 0 ;
13884 int val3 ;
13885 int ecode3 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "self",(char *) "x",(char *) "y", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13895 if (!SWIG_IsOK(res1)) {
13896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13897 }
13898 arg1 = reinterpret_cast< wxImage * >(argp1);
13899 ecode2 = SWIG_AsVal_int(obj1, &val2);
13900 if (!SWIG_IsOK(ecode2)) {
13901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13902 }
13903 arg2 = static_cast< int >(val2);
13904 ecode3 = SWIG_AsVal_int(obj2, &val3);
13905 if (!SWIG_IsOK(ecode3)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13907 }
13908 arg3 = static_cast< int >(val3);
13909 {
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 result = (byte)(arg1)->GetGreen(arg2,arg3);
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13923 PyObject *resultobj = 0;
13924 wxImage *arg1 = (wxImage *) 0 ;
13925 int arg2 ;
13926 int arg3 ;
13927 byte result;
13928 void *argp1 = 0 ;
13929 int res1 = 0 ;
13930 int val2 ;
13931 int ecode2 = 0 ;
13932 int val3 ;
13933 int ecode3 = 0 ;
13934 PyObject * obj0 = 0 ;
13935 PyObject * obj1 = 0 ;
13936 PyObject * obj2 = 0 ;
13937 char * kwnames[] = {
13938 (char *) "self",(char *) "x",(char *) "y", NULL
13939 };
13940
13941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13943 if (!SWIG_IsOK(res1)) {
13944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13945 }
13946 arg1 = reinterpret_cast< wxImage * >(argp1);
13947 ecode2 = SWIG_AsVal_int(obj1, &val2);
13948 if (!SWIG_IsOK(ecode2)) {
13949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13950 }
13951 arg2 = static_cast< int >(val2);
13952 ecode3 = SWIG_AsVal_int(obj2, &val3);
13953 if (!SWIG_IsOK(ecode3)) {
13954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13955 }
13956 arg3 = static_cast< int >(val3);
13957 {
13958 PyThreadState* __tstate = wxPyBeginAllowThreads();
13959 result = (byte)(arg1)->GetBlue(arg2,arg3);
13960 wxPyEndAllowThreads(__tstate);
13961 if (PyErr_Occurred()) SWIG_fail;
13962 }
13963 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13964 return resultobj;
13965 fail:
13966 return NULL;
13967 }
13968
13969
13970 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13971 PyObject *resultobj = 0;
13972 wxImage *arg1 = (wxImage *) 0 ;
13973 int arg2 ;
13974 int arg3 ;
13975 byte arg4 ;
13976 void *argp1 = 0 ;
13977 int res1 = 0 ;
13978 int val2 ;
13979 int ecode2 = 0 ;
13980 int val3 ;
13981 int ecode3 = 0 ;
13982 unsigned char val4 ;
13983 int ecode4 = 0 ;
13984 PyObject * obj0 = 0 ;
13985 PyObject * obj1 = 0 ;
13986 PyObject * obj2 = 0 ;
13987 PyObject * obj3 = 0 ;
13988 char * kwnames[] = {
13989 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13990 };
13991
13992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13994 if (!SWIG_IsOK(res1)) {
13995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13996 }
13997 arg1 = reinterpret_cast< wxImage * >(argp1);
13998 ecode2 = SWIG_AsVal_int(obj1, &val2);
13999 if (!SWIG_IsOK(ecode2)) {
14000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14001 }
14002 arg2 = static_cast< int >(val2);
14003 ecode3 = SWIG_AsVal_int(obj2, &val3);
14004 if (!SWIG_IsOK(ecode3)) {
14005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14006 }
14007 arg3 = static_cast< int >(val3);
14008 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14009 if (!SWIG_IsOK(ecode4)) {
14010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14011 }
14012 arg4 = static_cast< byte >(val4);
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 (arg1)->SetAlpha(arg2,arg3,arg4);
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 resultobj = SWIG_Py_Void();
14020 return resultobj;
14021 fail:
14022 return NULL;
14023 }
14024
14025
14026 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14027 PyObject *resultobj = 0;
14028 wxImage *arg1 = (wxImage *) 0 ;
14029 int arg2 ;
14030 int arg3 ;
14031 byte result;
14032 void *argp1 = 0 ;
14033 int res1 = 0 ;
14034 int val2 ;
14035 int ecode2 = 0 ;
14036 int val3 ;
14037 int ecode3 = 0 ;
14038 PyObject * obj0 = 0 ;
14039 PyObject * obj1 = 0 ;
14040 PyObject * obj2 = 0 ;
14041 char * kwnames[] = {
14042 (char *) "self",(char *) "x",(char *) "y", NULL
14043 };
14044
14045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14047 if (!SWIG_IsOK(res1)) {
14048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14049 }
14050 arg1 = reinterpret_cast< wxImage * >(argp1);
14051 ecode2 = SWIG_AsVal_int(obj1, &val2);
14052 if (!SWIG_IsOK(ecode2)) {
14053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14054 }
14055 arg2 = static_cast< int >(val2);
14056 ecode3 = SWIG_AsVal_int(obj2, &val3);
14057 if (!SWIG_IsOK(ecode3)) {
14058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14059 }
14060 arg3 = static_cast< int >(val3);
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14075 PyObject *resultobj = 0;
14076 wxImage *arg1 = (wxImage *) 0 ;
14077 bool result;
14078 void *argp1 = 0 ;
14079 int res1 = 0 ;
14080 PyObject *swig_obj[1] ;
14081
14082 if (!args) SWIG_fail;
14083 swig_obj[0] = args;
14084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14085 if (!SWIG_IsOK(res1)) {
14086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14087 }
14088 arg1 = reinterpret_cast< wxImage * >(argp1);
14089 {
14090 PyThreadState* __tstate = wxPyBeginAllowThreads();
14091 result = (bool)(arg1)->HasAlpha();
14092 wxPyEndAllowThreads(__tstate);
14093 if (PyErr_Occurred()) SWIG_fail;
14094 }
14095 {
14096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14097 }
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14105 PyObject *resultobj = 0;
14106 wxImage *arg1 = (wxImage *) 0 ;
14107 void *argp1 = 0 ;
14108 int res1 = 0 ;
14109 PyObject *swig_obj[1] ;
14110
14111 if (!args) SWIG_fail;
14112 swig_obj[0] = args;
14113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14114 if (!SWIG_IsOK(res1)) {
14115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14116 }
14117 arg1 = reinterpret_cast< wxImage * >(argp1);
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 (arg1)->InitAlpha();
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 resultobj = SWIG_Py_Void();
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14132 PyObject *resultobj = 0;
14133 wxImage *arg1 = (wxImage *) 0 ;
14134 int arg2 ;
14135 int arg3 ;
14136 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14137 bool result;
14138 void *argp1 = 0 ;
14139 int res1 = 0 ;
14140 int val2 ;
14141 int ecode2 = 0 ;
14142 int val3 ;
14143 int ecode3 = 0 ;
14144 unsigned char val4 ;
14145 int ecode4 = 0 ;
14146 PyObject * obj0 = 0 ;
14147 PyObject * obj1 = 0 ;
14148 PyObject * obj2 = 0 ;
14149 PyObject * obj3 = 0 ;
14150 char * kwnames[] = {
14151 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14152 };
14153
14154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14156 if (!SWIG_IsOK(res1)) {
14157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14158 }
14159 arg1 = reinterpret_cast< wxImage * >(argp1);
14160 ecode2 = SWIG_AsVal_int(obj1, &val2);
14161 if (!SWIG_IsOK(ecode2)) {
14162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14163 }
14164 arg2 = static_cast< int >(val2);
14165 ecode3 = SWIG_AsVal_int(obj2, &val3);
14166 if (!SWIG_IsOK(ecode3)) {
14167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14168 }
14169 arg3 = static_cast< int >(val3);
14170 if (obj3) {
14171 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14172 if (!SWIG_IsOK(ecode4)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14174 }
14175 arg4 = static_cast< byte >(val4);
14176 }
14177 {
14178 PyThreadState* __tstate = wxPyBeginAllowThreads();
14179 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 {
14184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14185 }
14186 return resultobj;
14187 fail:
14188 return NULL;
14189 }
14190
14191
14192 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14193 PyObject *resultobj = 0;
14194 wxImage *arg1 = (wxImage *) 0 ;
14195 byte *arg2 = (byte *) 0 ;
14196 byte *arg3 = (byte *) 0 ;
14197 byte *arg4 = (byte *) 0 ;
14198 byte arg5 = (byte) 0 ;
14199 byte arg6 = (byte) 0 ;
14200 byte arg7 = (byte) 0 ;
14201 bool result;
14202 void *argp1 = 0 ;
14203 int res1 = 0 ;
14204 byte temp2 ;
14205 int res2 = SWIG_TMPOBJ ;
14206 byte temp3 ;
14207 int res3 = SWIG_TMPOBJ ;
14208 byte temp4 ;
14209 int res4 = SWIG_TMPOBJ ;
14210 unsigned char val5 ;
14211 int ecode5 = 0 ;
14212 unsigned char val6 ;
14213 int ecode6 = 0 ;
14214 unsigned char val7 ;
14215 int ecode7 = 0 ;
14216 PyObject * obj0 = 0 ;
14217 PyObject * obj1 = 0 ;
14218 PyObject * obj2 = 0 ;
14219 PyObject * obj3 = 0 ;
14220 char * kwnames[] = {
14221 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14222 };
14223
14224 arg2 = &temp2;
14225 arg3 = &temp3;
14226 arg4 = &temp4;
14227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14229 if (!SWIG_IsOK(res1)) {
14230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14231 }
14232 arg1 = reinterpret_cast< wxImage * >(argp1);
14233 if (obj1) {
14234 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14235 if (!SWIG_IsOK(ecode5)) {
14236 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14237 }
14238 arg5 = static_cast< byte >(val5);
14239 }
14240 if (obj2) {
14241 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14242 if (!SWIG_IsOK(ecode6)) {
14243 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14244 }
14245 arg6 = static_cast< byte >(val6);
14246 }
14247 if (obj3) {
14248 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14249 if (!SWIG_IsOK(ecode7)) {
14250 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14251 }
14252 arg7 = static_cast< byte >(val7);
14253 }
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 {
14261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14262 }
14263 if (SWIG_IsTmpObj(res2)) {
14264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14265 } else {
14266 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14268 }
14269 if (SWIG_IsTmpObj(res3)) {
14270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14271 } else {
14272 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14274 }
14275 if (SWIG_IsTmpObj(res4)) {
14276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14277 } else {
14278 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14280 }
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj = 0;
14289 wxImage *arg1 = (wxImage *) 0 ;
14290 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14291 bool result;
14292 void *argp1 = 0 ;
14293 int res1 = 0 ;
14294 unsigned char val2 ;
14295 int ecode2 = 0 ;
14296 PyObject * obj0 = 0 ;
14297 PyObject * obj1 = 0 ;
14298 char * kwnames[] = {
14299 (char *) "self",(char *) "threshold", NULL
14300 };
14301
14302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14304 if (!SWIG_IsOK(res1)) {
14305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14306 }
14307 arg1 = reinterpret_cast< wxImage * >(argp1);
14308 if (obj1) {
14309 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14310 if (!SWIG_IsOK(ecode2)) {
14311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14312 }
14313 arg2 = static_cast< byte >(val2);
14314 }
14315 {
14316 PyThreadState* __tstate = wxPyBeginAllowThreads();
14317 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14318 wxPyEndAllowThreads(__tstate);
14319 if (PyErr_Occurred()) SWIG_fail;
14320 }
14321 {
14322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14323 }
14324 return resultobj;
14325 fail:
14326 return NULL;
14327 }
14328
14329
14330 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14331 PyObject *resultobj = 0;
14332 wxImage *arg1 = (wxImage *) 0 ;
14333 byte arg2 ;
14334 byte arg3 ;
14335 byte arg4 ;
14336 bool result;
14337 void *argp1 = 0 ;
14338 int res1 = 0 ;
14339 unsigned char val2 ;
14340 int ecode2 = 0 ;
14341 unsigned char val3 ;
14342 int ecode3 = 0 ;
14343 unsigned char val4 ;
14344 int ecode4 = 0 ;
14345 PyObject * obj0 = 0 ;
14346 PyObject * obj1 = 0 ;
14347 PyObject * obj2 = 0 ;
14348 PyObject * obj3 = 0 ;
14349 char * kwnames[] = {
14350 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14351 };
14352
14353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14355 if (!SWIG_IsOK(res1)) {
14356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14357 }
14358 arg1 = reinterpret_cast< wxImage * >(argp1);
14359 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14360 if (!SWIG_IsOK(ecode2)) {
14361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14362 }
14363 arg2 = static_cast< byte >(val2);
14364 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14365 if (!SWIG_IsOK(ecode3)) {
14366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14367 }
14368 arg3 = static_cast< byte >(val3);
14369 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14370 if (!SWIG_IsOK(ecode4)) {
14371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14372 }
14373 arg4 = static_cast< byte >(val4);
14374 {
14375 PyThreadState* __tstate = wxPyBeginAllowThreads();
14376 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14377 wxPyEndAllowThreads(__tstate);
14378 if (PyErr_Occurred()) SWIG_fail;
14379 }
14380 {
14381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14382 }
14383 return resultobj;
14384 fail:
14385 return NULL;
14386 }
14387
14388
14389 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14390 PyObject *resultobj = 0;
14391 wxImage *arg1 = (wxImage *) 0 ;
14392 wxImage *arg2 = 0 ;
14393 byte arg3 ;
14394 byte arg4 ;
14395 byte arg5 ;
14396 bool result;
14397 void *argp1 = 0 ;
14398 int res1 = 0 ;
14399 void *argp2 = 0 ;
14400 int res2 = 0 ;
14401 unsigned char val3 ;
14402 int ecode3 = 0 ;
14403 unsigned char val4 ;
14404 int ecode4 = 0 ;
14405 unsigned char val5 ;
14406 int ecode5 = 0 ;
14407 PyObject * obj0 = 0 ;
14408 PyObject * obj1 = 0 ;
14409 PyObject * obj2 = 0 ;
14410 PyObject * obj3 = 0 ;
14411 PyObject * obj4 = 0 ;
14412 char * kwnames[] = {
14413 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14414 };
14415
14416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14420 }
14421 arg1 = reinterpret_cast< wxImage * >(argp1);
14422 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14423 if (!SWIG_IsOK(res2)) {
14424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14425 }
14426 if (!argp2) {
14427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14428 }
14429 arg2 = reinterpret_cast< wxImage * >(argp2);
14430 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14431 if (!SWIG_IsOK(ecode3)) {
14432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14433 }
14434 arg3 = static_cast< byte >(val3);
14435 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14436 if (!SWIG_IsOK(ecode4)) {
14437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14438 }
14439 arg4 = static_cast< byte >(val4);
14440 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14441 if (!SWIG_IsOK(ecode5)) {
14442 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14443 }
14444 arg5 = static_cast< byte >(val5);
14445 {
14446 PyThreadState* __tstate = wxPyBeginAllowThreads();
14447 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14448 wxPyEndAllowThreads(__tstate);
14449 if (PyErr_Occurred()) SWIG_fail;
14450 }
14451 {
14452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14453 }
14454 return resultobj;
14455 fail:
14456 return NULL;
14457 }
14458
14459
14460 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14461 PyObject *resultobj = 0;
14462 wxString *arg1 = 0 ;
14463 bool result;
14464 bool temp1 = false ;
14465 PyObject * obj0 = 0 ;
14466 char * kwnames[] = {
14467 (char *) "filename", NULL
14468 };
14469
14470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14471 {
14472 arg1 = wxString_in_helper(obj0);
14473 if (arg1 == NULL) SWIG_fail;
14474 temp1 = true;
14475 }
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 {
14483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14484 }
14485 {
14486 if (temp1)
14487 delete arg1;
14488 }
14489 return resultobj;
14490 fail:
14491 {
14492 if (temp1)
14493 delete arg1;
14494 }
14495 return NULL;
14496 }
14497
14498
14499 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14500 PyObject *resultobj = 0;
14501 wxString *arg1 = 0 ;
14502 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14503 int result;
14504 bool temp1 = false ;
14505 long val2 ;
14506 int ecode2 = 0 ;
14507 PyObject * obj0 = 0 ;
14508 PyObject * obj1 = 0 ;
14509 char * kwnames[] = {
14510 (char *) "filename",(char *) "type", NULL
14511 };
14512
14513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14514 {
14515 arg1 = wxString_in_helper(obj0);
14516 if (arg1 == NULL) SWIG_fail;
14517 temp1 = true;
14518 }
14519 if (obj1) {
14520 ecode2 = SWIG_AsVal_long(obj1, &val2);
14521 if (!SWIG_IsOK(ecode2)) {
14522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14523 }
14524 arg2 = static_cast< long >(val2);
14525 }
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 resultobj = SWIG_From_int(static_cast< int >(result));
14533 {
14534 if (temp1)
14535 delete arg1;
14536 }
14537 return resultobj;
14538 fail:
14539 {
14540 if (temp1)
14541 delete arg1;
14542 }
14543 return NULL;
14544 }
14545
14546
14547 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14548 PyObject *resultobj = 0;
14549 wxImage *arg1 = (wxImage *) 0 ;
14550 wxString *arg2 = 0 ;
14551 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14552 int arg4 = (int) -1 ;
14553 bool result;
14554 void *argp1 = 0 ;
14555 int res1 = 0 ;
14556 bool temp2 = false ;
14557 long val3 ;
14558 int ecode3 = 0 ;
14559 int val4 ;
14560 int ecode4 = 0 ;
14561 PyObject * obj0 = 0 ;
14562 PyObject * obj1 = 0 ;
14563 PyObject * obj2 = 0 ;
14564 PyObject * obj3 = 0 ;
14565 char * kwnames[] = {
14566 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14567 };
14568
14569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14571 if (!SWIG_IsOK(res1)) {
14572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14573 }
14574 arg1 = reinterpret_cast< wxImage * >(argp1);
14575 {
14576 arg2 = wxString_in_helper(obj1);
14577 if (arg2 == NULL) SWIG_fail;
14578 temp2 = true;
14579 }
14580 if (obj2) {
14581 ecode3 = SWIG_AsVal_long(obj2, &val3);
14582 if (!SWIG_IsOK(ecode3)) {
14583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14584 }
14585 arg3 = static_cast< long >(val3);
14586 }
14587 if (obj3) {
14588 ecode4 = SWIG_AsVal_int(obj3, &val4);
14589 if (!SWIG_IsOK(ecode4)) {
14590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14591 }
14592 arg4 = static_cast< int >(val4);
14593 }
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14597 wxPyEndAllowThreads(__tstate);
14598 if (PyErr_Occurred()) SWIG_fail;
14599 }
14600 {
14601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14602 }
14603 {
14604 if (temp2)
14605 delete arg2;
14606 }
14607 return resultobj;
14608 fail:
14609 {
14610 if (temp2)
14611 delete arg2;
14612 }
14613 return NULL;
14614 }
14615
14616
14617 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14618 PyObject *resultobj = 0;
14619 wxImage *arg1 = (wxImage *) 0 ;
14620 wxString *arg2 = 0 ;
14621 wxString *arg3 = 0 ;
14622 int arg4 = (int) -1 ;
14623 bool result;
14624 void *argp1 = 0 ;
14625 int res1 = 0 ;
14626 bool temp2 = false ;
14627 bool temp3 = false ;
14628 int val4 ;
14629 int ecode4 = 0 ;
14630 PyObject * obj0 = 0 ;
14631 PyObject * obj1 = 0 ;
14632 PyObject * obj2 = 0 ;
14633 PyObject * obj3 = 0 ;
14634 char * kwnames[] = {
14635 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14636 };
14637
14638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14640 if (!SWIG_IsOK(res1)) {
14641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14642 }
14643 arg1 = reinterpret_cast< wxImage * >(argp1);
14644 {
14645 arg2 = wxString_in_helper(obj1);
14646 if (arg2 == NULL) SWIG_fail;
14647 temp2 = true;
14648 }
14649 {
14650 arg3 = wxString_in_helper(obj2);
14651 if (arg3 == NULL) SWIG_fail;
14652 temp3 = true;
14653 }
14654 if (obj3) {
14655 ecode4 = SWIG_AsVal_int(obj3, &val4);
14656 if (!SWIG_IsOK(ecode4)) {
14657 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14658 }
14659 arg4 = static_cast< int >(val4);
14660 }
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 {
14668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14669 }
14670 {
14671 if (temp2)
14672 delete arg2;
14673 }
14674 {
14675 if (temp3)
14676 delete arg3;
14677 }
14678 return resultobj;
14679 fail:
14680 {
14681 if (temp2)
14682 delete arg2;
14683 }
14684 {
14685 if (temp3)
14686 delete arg3;
14687 }
14688 return NULL;
14689 }
14690
14691
14692 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14693 PyObject *resultobj = 0;
14694 wxImage *arg1 = (wxImage *) 0 ;
14695 wxString *arg2 = 0 ;
14696 int arg3 ;
14697 bool result;
14698 void *argp1 = 0 ;
14699 int res1 = 0 ;
14700 bool temp2 = false ;
14701 int val3 ;
14702 int ecode3 = 0 ;
14703 PyObject * obj0 = 0 ;
14704 PyObject * obj1 = 0 ;
14705 PyObject * obj2 = 0 ;
14706 char * kwnames[] = {
14707 (char *) "self",(char *) "name",(char *) "type", NULL
14708 };
14709
14710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14712 if (!SWIG_IsOK(res1)) {
14713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14714 }
14715 arg1 = reinterpret_cast< wxImage * >(argp1);
14716 {
14717 arg2 = wxString_in_helper(obj1);
14718 if (arg2 == NULL) SWIG_fail;
14719 temp2 = true;
14720 }
14721 ecode3 = SWIG_AsVal_int(obj2, &val3);
14722 if (!SWIG_IsOK(ecode3)) {
14723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14724 }
14725 arg3 = static_cast< int >(val3);
14726 {
14727 PyThreadState* __tstate = wxPyBeginAllowThreads();
14728 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14729 wxPyEndAllowThreads(__tstate);
14730 if (PyErr_Occurred()) SWIG_fail;
14731 }
14732 {
14733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14734 }
14735 {
14736 if (temp2)
14737 delete arg2;
14738 }
14739 return resultobj;
14740 fail:
14741 {
14742 if (temp2)
14743 delete arg2;
14744 }
14745 return NULL;
14746 }
14747
14748
14749 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14750 PyObject *resultobj = 0;
14751 wxImage *arg1 = (wxImage *) 0 ;
14752 wxString *arg2 = 0 ;
14753 wxString *arg3 = 0 ;
14754 bool result;
14755 void *argp1 = 0 ;
14756 int res1 = 0 ;
14757 bool temp2 = false ;
14758 bool temp3 = false ;
14759 PyObject * obj0 = 0 ;
14760 PyObject * obj1 = 0 ;
14761 PyObject * obj2 = 0 ;
14762 char * kwnames[] = {
14763 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14764 };
14765
14766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14768 if (!SWIG_IsOK(res1)) {
14769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14770 }
14771 arg1 = reinterpret_cast< wxImage * >(argp1);
14772 {
14773 arg2 = wxString_in_helper(obj1);
14774 if (arg2 == NULL) SWIG_fail;
14775 temp2 = true;
14776 }
14777 {
14778 arg3 = wxString_in_helper(obj2);
14779 if (arg3 == NULL) SWIG_fail;
14780 temp3 = true;
14781 }
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14785 wxPyEndAllowThreads(__tstate);
14786 if (PyErr_Occurred()) SWIG_fail;
14787 }
14788 {
14789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14790 }
14791 {
14792 if (temp2)
14793 delete arg2;
14794 }
14795 {
14796 if (temp3)
14797 delete arg3;
14798 }
14799 return resultobj;
14800 fail:
14801 {
14802 if (temp2)
14803 delete arg2;
14804 }
14805 {
14806 if (temp3)
14807 delete arg3;
14808 }
14809 return NULL;
14810 }
14811
14812
14813 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14814 PyObject *resultobj = 0;
14815 wxInputStream *arg1 = 0 ;
14816 bool result;
14817 wxPyInputStream *temp1 ;
14818 bool created1 ;
14819 PyObject * obj0 = 0 ;
14820 char * kwnames[] = {
14821 (char *) "stream", NULL
14822 };
14823
14824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14825 {
14826 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14827 arg1 = temp1->m_wxis;
14828 created1 = false;
14829 } else {
14830 PyErr_Clear(); // clear the failure of the wxPyConvert above
14831 arg1 = wxPyCBInputStream_create(obj0, false);
14832 if (arg1 == NULL) {
14833 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14834 SWIG_fail;
14835 }
14836 created1 = true;
14837 }
14838 }
14839 {
14840 PyThreadState* __tstate = wxPyBeginAllowThreads();
14841 result = (bool)wxImage::CanRead(*arg1);
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 {
14846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14847 }
14848 {
14849 if (created1) delete arg1;
14850 }
14851 return resultobj;
14852 fail:
14853 {
14854 if (created1) delete arg1;
14855 }
14856 return NULL;
14857 }
14858
14859
14860 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj = 0;
14862 wxImage *arg1 = (wxImage *) 0 ;
14863 wxInputStream *arg2 = 0 ;
14864 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14865 int arg4 = (int) -1 ;
14866 bool result;
14867 void *argp1 = 0 ;
14868 int res1 = 0 ;
14869 wxPyInputStream *temp2 ;
14870 bool created2 ;
14871 long val3 ;
14872 int ecode3 = 0 ;
14873 int val4 ;
14874 int ecode4 = 0 ;
14875 PyObject * obj0 = 0 ;
14876 PyObject * obj1 = 0 ;
14877 PyObject * obj2 = 0 ;
14878 PyObject * obj3 = 0 ;
14879 char * kwnames[] = {
14880 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14881 };
14882
14883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14885 if (!SWIG_IsOK(res1)) {
14886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14887 }
14888 arg1 = reinterpret_cast< wxImage * >(argp1);
14889 {
14890 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14891 arg2 = temp2->m_wxis;
14892 created2 = false;
14893 } else {
14894 PyErr_Clear(); // clear the failure of the wxPyConvert above
14895 arg2 = wxPyCBInputStream_create(obj1, false);
14896 if (arg2 == NULL) {
14897 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14898 SWIG_fail;
14899 }
14900 created2 = true;
14901 }
14902 }
14903 if (obj2) {
14904 ecode3 = SWIG_AsVal_long(obj2, &val3);
14905 if (!SWIG_IsOK(ecode3)) {
14906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14907 }
14908 arg3 = static_cast< long >(val3);
14909 }
14910 if (obj3) {
14911 ecode4 = SWIG_AsVal_int(obj3, &val4);
14912 if (!SWIG_IsOK(ecode4)) {
14913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14914 }
14915 arg4 = static_cast< int >(val4);
14916 }
14917 {
14918 PyThreadState* __tstate = wxPyBeginAllowThreads();
14919 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 {
14924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14925 }
14926 {
14927 if (created2) delete arg2;
14928 }
14929 return resultobj;
14930 fail:
14931 {
14932 if (created2) delete arg2;
14933 }
14934 return NULL;
14935 }
14936
14937
14938 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14939 PyObject *resultobj = 0;
14940 wxImage *arg1 = (wxImage *) 0 ;
14941 wxInputStream *arg2 = 0 ;
14942 wxString *arg3 = 0 ;
14943 int arg4 = (int) -1 ;
14944 bool result;
14945 void *argp1 = 0 ;
14946 int res1 = 0 ;
14947 wxPyInputStream *temp2 ;
14948 bool created2 ;
14949 bool temp3 = false ;
14950 int val4 ;
14951 int ecode4 = 0 ;
14952 PyObject * obj0 = 0 ;
14953 PyObject * obj1 = 0 ;
14954 PyObject * obj2 = 0 ;
14955 PyObject * obj3 = 0 ;
14956 char * kwnames[] = {
14957 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14958 };
14959
14960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14962 if (!SWIG_IsOK(res1)) {
14963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14964 }
14965 arg1 = reinterpret_cast< wxImage * >(argp1);
14966 {
14967 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14968 arg2 = temp2->m_wxis;
14969 created2 = false;
14970 } else {
14971 PyErr_Clear(); // clear the failure of the wxPyConvert above
14972 arg2 = wxPyCBInputStream_create(obj1, false);
14973 if (arg2 == NULL) {
14974 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14975 SWIG_fail;
14976 }
14977 created2 = true;
14978 }
14979 }
14980 {
14981 arg3 = wxString_in_helper(obj2);
14982 if (arg3 == NULL) SWIG_fail;
14983 temp3 = true;
14984 }
14985 if (obj3) {
14986 ecode4 = SWIG_AsVal_int(obj3, &val4);
14987 if (!SWIG_IsOK(ecode4)) {
14988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14989 }
14990 arg4 = static_cast< int >(val4);
14991 }
14992 {
14993 PyThreadState* __tstate = wxPyBeginAllowThreads();
14994 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14995 wxPyEndAllowThreads(__tstate);
14996 if (PyErr_Occurred()) SWIG_fail;
14997 }
14998 {
14999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15000 }
15001 {
15002 if (created2) delete arg2;
15003 }
15004 {
15005 if (temp3)
15006 delete arg3;
15007 }
15008 return resultobj;
15009 fail:
15010 {
15011 if (created2) delete arg2;
15012 }
15013 {
15014 if (temp3)
15015 delete arg3;
15016 }
15017 return NULL;
15018 }
15019
15020
15021 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15022 PyObject *resultobj = 0;
15023 wxImage *arg1 = (wxImage *) 0 ;
15024 bool result;
15025 void *argp1 = 0 ;
15026 int res1 = 0 ;
15027 PyObject *swig_obj[1] ;
15028
15029 if (!args) SWIG_fail;
15030 swig_obj[0] = args;
15031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15032 if (!SWIG_IsOK(res1)) {
15033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15034 }
15035 arg1 = reinterpret_cast< wxImage * >(argp1);
15036 {
15037 PyThreadState* __tstate = wxPyBeginAllowThreads();
15038 result = (bool)(arg1)->Ok();
15039 wxPyEndAllowThreads(__tstate);
15040 if (PyErr_Occurred()) SWIG_fail;
15041 }
15042 {
15043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15044 }
15045 return resultobj;
15046 fail:
15047 return NULL;
15048 }
15049
15050
15051 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15052 PyObject *resultobj = 0;
15053 wxImage *arg1 = (wxImage *) 0 ;
15054 int result;
15055 void *argp1 = 0 ;
15056 int res1 = 0 ;
15057 PyObject *swig_obj[1] ;
15058
15059 if (!args) SWIG_fail;
15060 swig_obj[0] = args;
15061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15062 if (!SWIG_IsOK(res1)) {
15063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15064 }
15065 arg1 = reinterpret_cast< wxImage * >(argp1);
15066 {
15067 PyThreadState* __tstate = wxPyBeginAllowThreads();
15068 result = (int)(arg1)->GetWidth();
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 resultobj = SWIG_From_int(static_cast< int >(result));
15073 return resultobj;
15074 fail:
15075 return NULL;
15076 }
15077
15078
15079 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15080 PyObject *resultobj = 0;
15081 wxImage *arg1 = (wxImage *) 0 ;
15082 int result;
15083 void *argp1 = 0 ;
15084 int res1 = 0 ;
15085 PyObject *swig_obj[1] ;
15086
15087 if (!args) SWIG_fail;
15088 swig_obj[0] = args;
15089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15090 if (!SWIG_IsOK(res1)) {
15091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15092 }
15093 arg1 = reinterpret_cast< wxImage * >(argp1);
15094 {
15095 PyThreadState* __tstate = wxPyBeginAllowThreads();
15096 result = (int)(arg1)->GetHeight();
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 resultobj = SWIG_From_int(static_cast< int >(result));
15101 return resultobj;
15102 fail:
15103 return NULL;
15104 }
15105
15106
15107 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15108 PyObject *resultobj = 0;
15109 wxImage *arg1 = (wxImage *) 0 ;
15110 wxSize result;
15111 void *argp1 = 0 ;
15112 int res1 = 0 ;
15113 PyObject *swig_obj[1] ;
15114
15115 if (!args) SWIG_fail;
15116 swig_obj[0] = args;
15117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15118 if (!SWIG_IsOK(res1)) {
15119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15120 }
15121 arg1 = reinterpret_cast< wxImage * >(argp1);
15122 {
15123 PyThreadState* __tstate = wxPyBeginAllowThreads();
15124 result = wxImage_GetSize(arg1);
15125 wxPyEndAllowThreads(__tstate);
15126 if (PyErr_Occurred()) SWIG_fail;
15127 }
15128 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15129 return resultobj;
15130 fail:
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj = 0;
15137 wxImage *arg1 = (wxImage *) 0 ;
15138 wxRect *arg2 = 0 ;
15139 SwigValueWrapper<wxImage > result;
15140 void *argp1 = 0 ;
15141 int res1 = 0 ;
15142 wxRect temp2 ;
15143 PyObject * obj0 = 0 ;
15144 PyObject * obj1 = 0 ;
15145 char * kwnames[] = {
15146 (char *) "self",(char *) "rect", NULL
15147 };
15148
15149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15151 if (!SWIG_IsOK(res1)) {
15152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15153 }
15154 arg1 = reinterpret_cast< wxImage * >(argp1);
15155 {
15156 arg2 = &temp2;
15157 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15158 }
15159 {
15160 PyThreadState* __tstate = wxPyBeginAllowThreads();
15161 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15162 wxPyEndAllowThreads(__tstate);
15163 if (PyErr_Occurred()) SWIG_fail;
15164 }
15165 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15166 return resultobj;
15167 fail:
15168 return NULL;
15169 }
15170
15171
15172 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15173 PyObject *resultobj = 0;
15174 wxImage *arg1 = (wxImage *) 0 ;
15175 wxSize *arg2 = 0 ;
15176 wxPoint *arg3 = 0 ;
15177 int arg4 = (int) -1 ;
15178 int arg5 = (int) -1 ;
15179 int arg6 = (int) -1 ;
15180 SwigValueWrapper<wxImage > result;
15181 void *argp1 = 0 ;
15182 int res1 = 0 ;
15183 wxSize temp2 ;
15184 wxPoint temp3 ;
15185 int val4 ;
15186 int ecode4 = 0 ;
15187 int val5 ;
15188 int ecode5 = 0 ;
15189 int val6 ;
15190 int ecode6 = 0 ;
15191 PyObject * obj0 = 0 ;
15192 PyObject * obj1 = 0 ;
15193 PyObject * obj2 = 0 ;
15194 PyObject * obj3 = 0 ;
15195 PyObject * obj4 = 0 ;
15196 PyObject * obj5 = 0 ;
15197 char * kwnames[] = {
15198 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15199 };
15200
15201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15203 if (!SWIG_IsOK(res1)) {
15204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15205 }
15206 arg1 = reinterpret_cast< wxImage * >(argp1);
15207 {
15208 arg2 = &temp2;
15209 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15210 }
15211 {
15212 arg3 = &temp3;
15213 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15214 }
15215 if (obj3) {
15216 ecode4 = SWIG_AsVal_int(obj3, &val4);
15217 if (!SWIG_IsOK(ecode4)) {
15218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15219 }
15220 arg4 = static_cast< int >(val4);
15221 }
15222 if (obj4) {
15223 ecode5 = SWIG_AsVal_int(obj4, &val5);
15224 if (!SWIG_IsOK(ecode5)) {
15225 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15226 }
15227 arg5 = static_cast< int >(val5);
15228 }
15229 if (obj5) {
15230 ecode6 = SWIG_AsVal_int(obj5, &val6);
15231 if (!SWIG_IsOK(ecode6)) {
15232 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15233 }
15234 arg6 = static_cast< int >(val6);
15235 }
15236 {
15237 PyThreadState* __tstate = wxPyBeginAllowThreads();
15238 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15239 wxPyEndAllowThreads(__tstate);
15240 if (PyErr_Occurred()) SWIG_fail;
15241 }
15242 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15243 return resultobj;
15244 fail:
15245 return NULL;
15246 }
15247
15248
15249 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15250 PyObject *resultobj = 0;
15251 wxImage *arg1 = (wxImage *) 0 ;
15252 SwigValueWrapper<wxImage > result;
15253 void *argp1 = 0 ;
15254 int res1 = 0 ;
15255 PyObject *swig_obj[1] ;
15256
15257 if (!args) SWIG_fail;
15258 swig_obj[0] = args;
15259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15260 if (!SWIG_IsOK(res1)) {
15261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15262 }
15263 arg1 = reinterpret_cast< wxImage * >(argp1);
15264 {
15265 PyThreadState* __tstate = wxPyBeginAllowThreads();
15266 result = (arg1)->Copy();
15267 wxPyEndAllowThreads(__tstate);
15268 if (PyErr_Occurred()) SWIG_fail;
15269 }
15270 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15271 return resultobj;
15272 fail:
15273 return NULL;
15274 }
15275
15276
15277 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15278 PyObject *resultobj = 0;
15279 wxImage *arg1 = (wxImage *) 0 ;
15280 wxImage *arg2 = 0 ;
15281 int arg3 ;
15282 int arg4 ;
15283 void *argp1 = 0 ;
15284 int res1 = 0 ;
15285 void *argp2 = 0 ;
15286 int res2 = 0 ;
15287 int val3 ;
15288 int ecode3 = 0 ;
15289 int val4 ;
15290 int ecode4 = 0 ;
15291 PyObject * obj0 = 0 ;
15292 PyObject * obj1 = 0 ;
15293 PyObject * obj2 = 0 ;
15294 PyObject * obj3 = 0 ;
15295 char * kwnames[] = {
15296 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15297 };
15298
15299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15301 if (!SWIG_IsOK(res1)) {
15302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15303 }
15304 arg1 = reinterpret_cast< wxImage * >(argp1);
15305 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15306 if (!SWIG_IsOK(res2)) {
15307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15308 }
15309 if (!argp2) {
15310 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15311 }
15312 arg2 = reinterpret_cast< wxImage * >(argp2);
15313 ecode3 = SWIG_AsVal_int(obj2, &val3);
15314 if (!SWIG_IsOK(ecode3)) {
15315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15316 }
15317 arg3 = static_cast< int >(val3);
15318 ecode4 = SWIG_AsVal_int(obj3, &val4);
15319 if (!SWIG_IsOK(ecode4)) {
15320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15321 }
15322 arg4 = static_cast< int >(val4);
15323 {
15324 PyThreadState* __tstate = wxPyBeginAllowThreads();
15325 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 resultobj = SWIG_Py_Void();
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15337 PyObject *resultobj = 0;
15338 wxImage *arg1 = (wxImage *) 0 ;
15339 PyObject *result = 0 ;
15340 void *argp1 = 0 ;
15341 int res1 = 0 ;
15342 PyObject *swig_obj[1] ;
15343
15344 if (!args) SWIG_fail;
15345 swig_obj[0] = args;
15346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15347 if (!SWIG_IsOK(res1)) {
15348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15349 }
15350 arg1 = reinterpret_cast< wxImage * >(argp1);
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 result = (PyObject *)wxImage_GetData(arg1);
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 resultobj = result;
15358 return resultobj;
15359 fail:
15360 return NULL;
15361 }
15362
15363
15364 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15365 PyObject *resultobj = 0;
15366 wxImage *arg1 = (wxImage *) 0 ;
15367 buffer arg2 ;
15368 int arg3 ;
15369 void *argp1 = 0 ;
15370 int res1 = 0 ;
15371 PyObject * obj0 = 0 ;
15372 PyObject * obj1 = 0 ;
15373 char * kwnames[] = {
15374 (char *) "self",(char *) "data", NULL
15375 };
15376
15377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15379 if (!SWIG_IsOK(res1)) {
15380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15381 }
15382 arg1 = reinterpret_cast< wxImage * >(argp1);
15383 {
15384 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15385 }
15386 {
15387 PyThreadState* __tstate = wxPyBeginAllowThreads();
15388 wxImage_SetData(arg1,arg2,arg3);
15389 wxPyEndAllowThreads(__tstate);
15390 if (PyErr_Occurred()) SWIG_fail;
15391 }
15392 resultobj = SWIG_Py_Void();
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15400 PyObject *resultobj = 0;
15401 wxImage *arg1 = (wxImage *) 0 ;
15402 PyObject *result = 0 ;
15403 void *argp1 = 0 ;
15404 int res1 = 0 ;
15405 PyObject *swig_obj[1] ;
15406
15407 if (!args) SWIG_fail;
15408 swig_obj[0] = args;
15409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15412 }
15413 arg1 = reinterpret_cast< wxImage * >(argp1);
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 resultobj = result;
15421 return resultobj;
15422 fail:
15423 return NULL;
15424 }
15425
15426
15427 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15428 PyObject *resultobj = 0;
15429 wxImage *arg1 = (wxImage *) 0 ;
15430 buffer arg2 ;
15431 int arg3 ;
15432 void *argp1 = 0 ;
15433 int res1 = 0 ;
15434 PyObject * obj0 = 0 ;
15435 PyObject * obj1 = 0 ;
15436 char * kwnames[] = {
15437 (char *) "self",(char *) "data", NULL
15438 };
15439
15440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15442 if (!SWIG_IsOK(res1)) {
15443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15444 }
15445 arg1 = reinterpret_cast< wxImage * >(argp1);
15446 {
15447 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15448 }
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 wxImage_SetDataBuffer(arg1,arg2,arg3);
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 resultobj = SWIG_Py_Void();
15456 return resultobj;
15457 fail:
15458 return NULL;
15459 }
15460
15461
15462 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15463 PyObject *resultobj = 0;
15464 wxImage *arg1 = (wxImage *) 0 ;
15465 PyObject *result = 0 ;
15466 void *argp1 = 0 ;
15467 int res1 = 0 ;
15468 PyObject *swig_obj[1] ;
15469
15470 if (!args) SWIG_fail;
15471 swig_obj[0] = args;
15472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15473 if (!SWIG_IsOK(res1)) {
15474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15475 }
15476 arg1 = reinterpret_cast< wxImage * >(argp1);
15477 {
15478 PyThreadState* __tstate = wxPyBeginAllowThreads();
15479 result = (PyObject *)wxImage_GetAlphaData(arg1);
15480 wxPyEndAllowThreads(__tstate);
15481 if (PyErr_Occurred()) SWIG_fail;
15482 }
15483 resultobj = result;
15484 return resultobj;
15485 fail:
15486 return NULL;
15487 }
15488
15489
15490 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15491 PyObject *resultobj = 0;
15492 wxImage *arg1 = (wxImage *) 0 ;
15493 buffer arg2 ;
15494 int arg3 ;
15495 void *argp1 = 0 ;
15496 int res1 = 0 ;
15497 PyObject * obj0 = 0 ;
15498 PyObject * obj1 = 0 ;
15499 char * kwnames[] = {
15500 (char *) "self",(char *) "alpha", NULL
15501 };
15502
15503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15505 if (!SWIG_IsOK(res1)) {
15506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15507 }
15508 arg1 = reinterpret_cast< wxImage * >(argp1);
15509 {
15510 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15511 }
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 wxImage_SetAlphaData(arg1,arg2,arg3);
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_Py_Void();
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15526 PyObject *resultobj = 0;
15527 wxImage *arg1 = (wxImage *) 0 ;
15528 PyObject *result = 0 ;
15529 void *argp1 = 0 ;
15530 int res1 = 0 ;
15531 PyObject *swig_obj[1] ;
15532
15533 if (!args) SWIG_fail;
15534 swig_obj[0] = args;
15535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15536 if (!SWIG_IsOK(res1)) {
15537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15538 }
15539 arg1 = reinterpret_cast< wxImage * >(argp1);
15540 {
15541 PyThreadState* __tstate = wxPyBeginAllowThreads();
15542 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 resultobj = result;
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj = 0;
15555 wxImage *arg1 = (wxImage *) 0 ;
15556 buffer arg2 ;
15557 int arg3 ;
15558 void *argp1 = 0 ;
15559 int res1 = 0 ;
15560 PyObject * obj0 = 0 ;
15561 PyObject * obj1 = 0 ;
15562 char * kwnames[] = {
15563 (char *) "self",(char *) "alpha", NULL
15564 };
15565
15566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15570 }
15571 arg1 = reinterpret_cast< wxImage * >(argp1);
15572 {
15573 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_Py_Void();
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15589 PyObject *resultobj = 0;
15590 wxImage *arg1 = (wxImage *) 0 ;
15591 byte arg2 ;
15592 byte arg3 ;
15593 byte arg4 ;
15594 void *argp1 = 0 ;
15595 int res1 = 0 ;
15596 unsigned char val2 ;
15597 int ecode2 = 0 ;
15598 unsigned char val3 ;
15599 int ecode3 = 0 ;
15600 unsigned char val4 ;
15601 int ecode4 = 0 ;
15602 PyObject * obj0 = 0 ;
15603 PyObject * obj1 = 0 ;
15604 PyObject * obj2 = 0 ;
15605 PyObject * obj3 = 0 ;
15606 char * kwnames[] = {
15607 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15608 };
15609
15610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15612 if (!SWIG_IsOK(res1)) {
15613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15614 }
15615 arg1 = reinterpret_cast< wxImage * >(argp1);
15616 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15617 if (!SWIG_IsOK(ecode2)) {
15618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15619 }
15620 arg2 = static_cast< byte >(val2);
15621 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15622 if (!SWIG_IsOK(ecode3)) {
15623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15624 }
15625 arg3 = static_cast< byte >(val3);
15626 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15627 if (!SWIG_IsOK(ecode4)) {
15628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15629 }
15630 arg4 = static_cast< byte >(val4);
15631 {
15632 PyThreadState* __tstate = wxPyBeginAllowThreads();
15633 (arg1)->SetMaskColour(arg2,arg3,arg4);
15634 wxPyEndAllowThreads(__tstate);
15635 if (PyErr_Occurred()) SWIG_fail;
15636 }
15637 resultobj = SWIG_Py_Void();
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15645 PyObject *resultobj = 0;
15646 wxImage *arg1 = (wxImage *) 0 ;
15647 byte *arg2 = (byte *) 0 ;
15648 byte *arg3 = (byte *) 0 ;
15649 byte *arg4 = (byte *) 0 ;
15650 void *argp1 = 0 ;
15651 int res1 = 0 ;
15652 byte temp2 ;
15653 int res2 = SWIG_TMPOBJ ;
15654 byte temp3 ;
15655 int res3 = SWIG_TMPOBJ ;
15656 byte temp4 ;
15657 int res4 = SWIG_TMPOBJ ;
15658 PyObject *swig_obj[1] ;
15659
15660 arg2 = &temp2;
15661 arg3 = &temp3;
15662 arg4 = &temp4;
15663 if (!args) SWIG_fail;
15664 swig_obj[0] = args;
15665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15666 if (!SWIG_IsOK(res1)) {
15667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15668 }
15669 arg1 = reinterpret_cast< wxImage * >(argp1);
15670 {
15671 PyThreadState* __tstate = wxPyBeginAllowThreads();
15672 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 resultobj = SWIG_Py_Void();
15677 if (SWIG_IsTmpObj(res2)) {
15678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15679 } else {
15680 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15682 }
15683 if (SWIG_IsTmpObj(res3)) {
15684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15685 } else {
15686 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15687 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15688 }
15689 if (SWIG_IsTmpObj(res4)) {
15690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15691 } else {
15692 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15694 }
15695 return resultobj;
15696 fail:
15697 return NULL;
15698 }
15699
15700
15701 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15702 PyObject *resultobj = 0;
15703 wxImage *arg1 = (wxImage *) 0 ;
15704 byte result;
15705 void *argp1 = 0 ;
15706 int res1 = 0 ;
15707 PyObject *swig_obj[1] ;
15708
15709 if (!args) SWIG_fail;
15710 swig_obj[0] = args;
15711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15712 if (!SWIG_IsOK(res1)) {
15713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15714 }
15715 arg1 = reinterpret_cast< wxImage * >(argp1);
15716 {
15717 PyThreadState* __tstate = wxPyBeginAllowThreads();
15718 result = (byte)(arg1)->GetMaskRed();
15719 wxPyEndAllowThreads(__tstate);
15720 if (PyErr_Occurred()) SWIG_fail;
15721 }
15722 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15723 return resultobj;
15724 fail:
15725 return NULL;
15726 }
15727
15728
15729 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15730 PyObject *resultobj = 0;
15731 wxImage *arg1 = (wxImage *) 0 ;
15732 byte result;
15733 void *argp1 = 0 ;
15734 int res1 = 0 ;
15735 PyObject *swig_obj[1] ;
15736
15737 if (!args) SWIG_fail;
15738 swig_obj[0] = args;
15739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15740 if (!SWIG_IsOK(res1)) {
15741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15742 }
15743 arg1 = reinterpret_cast< wxImage * >(argp1);
15744 {
15745 PyThreadState* __tstate = wxPyBeginAllowThreads();
15746 result = (byte)(arg1)->GetMaskGreen();
15747 wxPyEndAllowThreads(__tstate);
15748 if (PyErr_Occurred()) SWIG_fail;
15749 }
15750 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15751 return resultobj;
15752 fail:
15753 return NULL;
15754 }
15755
15756
15757 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15758 PyObject *resultobj = 0;
15759 wxImage *arg1 = (wxImage *) 0 ;
15760 byte result;
15761 void *argp1 = 0 ;
15762 int res1 = 0 ;
15763 PyObject *swig_obj[1] ;
15764
15765 if (!args) SWIG_fail;
15766 swig_obj[0] = args;
15767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15768 if (!SWIG_IsOK(res1)) {
15769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15770 }
15771 arg1 = reinterpret_cast< wxImage * >(argp1);
15772 {
15773 PyThreadState* __tstate = wxPyBeginAllowThreads();
15774 result = (byte)(arg1)->GetMaskBlue();
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15786 PyObject *resultobj = 0;
15787 wxImage *arg1 = (wxImage *) 0 ;
15788 bool arg2 = (bool) true ;
15789 void *argp1 = 0 ;
15790 int res1 = 0 ;
15791 bool val2 ;
15792 int ecode2 = 0 ;
15793 PyObject * obj0 = 0 ;
15794 PyObject * obj1 = 0 ;
15795 char * kwnames[] = {
15796 (char *) "self",(char *) "mask", NULL
15797 };
15798
15799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15801 if (!SWIG_IsOK(res1)) {
15802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15803 }
15804 arg1 = reinterpret_cast< wxImage * >(argp1);
15805 if (obj1) {
15806 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15807 if (!SWIG_IsOK(ecode2)) {
15808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15809 }
15810 arg2 = static_cast< bool >(val2);
15811 }
15812 {
15813 PyThreadState* __tstate = wxPyBeginAllowThreads();
15814 (arg1)->SetMask(arg2);
15815 wxPyEndAllowThreads(__tstate);
15816 if (PyErr_Occurred()) SWIG_fail;
15817 }
15818 resultobj = SWIG_Py_Void();
15819 return resultobj;
15820 fail:
15821 return NULL;
15822 }
15823
15824
15825 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15826 PyObject *resultobj = 0;
15827 wxImage *arg1 = (wxImage *) 0 ;
15828 bool result;
15829 void *argp1 = 0 ;
15830 int res1 = 0 ;
15831 PyObject *swig_obj[1] ;
15832
15833 if (!args) SWIG_fail;
15834 swig_obj[0] = args;
15835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15836 if (!SWIG_IsOK(res1)) {
15837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15838 }
15839 arg1 = reinterpret_cast< wxImage * >(argp1);
15840 {
15841 PyThreadState* __tstate = wxPyBeginAllowThreads();
15842 result = (bool)(arg1)->HasMask();
15843 wxPyEndAllowThreads(__tstate);
15844 if (PyErr_Occurred()) SWIG_fail;
15845 }
15846 {
15847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15848 }
15849 return resultobj;
15850 fail:
15851 return NULL;
15852 }
15853
15854
15855 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15856 PyObject *resultobj = 0;
15857 wxImage *arg1 = (wxImage *) 0 ;
15858 double arg2 ;
15859 wxPoint *arg3 = 0 ;
15860 bool arg4 = (bool) true ;
15861 wxPoint *arg5 = (wxPoint *) NULL ;
15862 SwigValueWrapper<wxImage > result;
15863 void *argp1 = 0 ;
15864 int res1 = 0 ;
15865 double val2 ;
15866 int ecode2 = 0 ;
15867 wxPoint temp3 ;
15868 bool val4 ;
15869 int ecode4 = 0 ;
15870 void *argp5 = 0 ;
15871 int res5 = 0 ;
15872 PyObject * obj0 = 0 ;
15873 PyObject * obj1 = 0 ;
15874 PyObject * obj2 = 0 ;
15875 PyObject * obj3 = 0 ;
15876 PyObject * obj4 = 0 ;
15877 char * kwnames[] = {
15878 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15879 };
15880
15881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15883 if (!SWIG_IsOK(res1)) {
15884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15885 }
15886 arg1 = reinterpret_cast< wxImage * >(argp1);
15887 ecode2 = SWIG_AsVal_double(obj1, &val2);
15888 if (!SWIG_IsOK(ecode2)) {
15889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15890 }
15891 arg2 = static_cast< double >(val2);
15892 {
15893 arg3 = &temp3;
15894 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15895 }
15896 if (obj3) {
15897 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15898 if (!SWIG_IsOK(ecode4)) {
15899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15900 }
15901 arg4 = static_cast< bool >(val4);
15902 }
15903 if (obj4) {
15904 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15905 if (!SWIG_IsOK(res5)) {
15906 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15907 }
15908 arg5 = reinterpret_cast< wxPoint * >(argp5);
15909 }
15910 {
15911 PyThreadState* __tstate = wxPyBeginAllowThreads();
15912 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15913 wxPyEndAllowThreads(__tstate);
15914 if (PyErr_Occurred()) SWIG_fail;
15915 }
15916 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15917 return resultobj;
15918 fail:
15919 return NULL;
15920 }
15921
15922
15923 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15924 PyObject *resultobj = 0;
15925 wxImage *arg1 = (wxImage *) 0 ;
15926 bool arg2 = (bool) true ;
15927 SwigValueWrapper<wxImage > result;
15928 void *argp1 = 0 ;
15929 int res1 = 0 ;
15930 bool val2 ;
15931 int ecode2 = 0 ;
15932 PyObject * obj0 = 0 ;
15933 PyObject * obj1 = 0 ;
15934 char * kwnames[] = {
15935 (char *) "self",(char *) "clockwise", NULL
15936 };
15937
15938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15940 if (!SWIG_IsOK(res1)) {
15941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15942 }
15943 arg1 = reinterpret_cast< wxImage * >(argp1);
15944 if (obj1) {
15945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15946 if (!SWIG_IsOK(ecode2)) {
15947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15948 }
15949 arg2 = static_cast< bool >(val2);
15950 }
15951 {
15952 PyThreadState* __tstate = wxPyBeginAllowThreads();
15953 result = (arg1)->Rotate90(arg2);
15954 wxPyEndAllowThreads(__tstate);
15955 if (PyErr_Occurred()) SWIG_fail;
15956 }
15957 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15958 return resultobj;
15959 fail:
15960 return NULL;
15961 }
15962
15963
15964 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15965 PyObject *resultobj = 0;
15966 wxImage *arg1 = (wxImage *) 0 ;
15967 bool arg2 = (bool) true ;
15968 SwigValueWrapper<wxImage > result;
15969 void *argp1 = 0 ;
15970 int res1 = 0 ;
15971 bool val2 ;
15972 int ecode2 = 0 ;
15973 PyObject * obj0 = 0 ;
15974 PyObject * obj1 = 0 ;
15975 char * kwnames[] = {
15976 (char *) "self",(char *) "horizontally", NULL
15977 };
15978
15979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15981 if (!SWIG_IsOK(res1)) {
15982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15983 }
15984 arg1 = reinterpret_cast< wxImage * >(argp1);
15985 if (obj1) {
15986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15987 if (!SWIG_IsOK(ecode2)) {
15988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15989 }
15990 arg2 = static_cast< bool >(val2);
15991 }
15992 {
15993 PyThreadState* __tstate = wxPyBeginAllowThreads();
15994 result = (arg1)->Mirror(arg2);
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16006 PyObject *resultobj = 0;
16007 wxImage *arg1 = (wxImage *) 0 ;
16008 byte arg2 ;
16009 byte arg3 ;
16010 byte arg4 ;
16011 byte arg5 ;
16012 byte arg6 ;
16013 byte arg7 ;
16014 void *argp1 = 0 ;
16015 int res1 = 0 ;
16016 unsigned char val2 ;
16017 int ecode2 = 0 ;
16018 unsigned char val3 ;
16019 int ecode3 = 0 ;
16020 unsigned char val4 ;
16021 int ecode4 = 0 ;
16022 unsigned char val5 ;
16023 int ecode5 = 0 ;
16024 unsigned char val6 ;
16025 int ecode6 = 0 ;
16026 unsigned char val7 ;
16027 int ecode7 = 0 ;
16028 PyObject * obj0 = 0 ;
16029 PyObject * obj1 = 0 ;
16030 PyObject * obj2 = 0 ;
16031 PyObject * obj3 = 0 ;
16032 PyObject * obj4 = 0 ;
16033 PyObject * obj5 = 0 ;
16034 PyObject * obj6 = 0 ;
16035 char * kwnames[] = {
16036 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16037 };
16038
16039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16041 if (!SWIG_IsOK(res1)) {
16042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16043 }
16044 arg1 = reinterpret_cast< wxImage * >(argp1);
16045 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16046 if (!SWIG_IsOK(ecode2)) {
16047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16048 }
16049 arg2 = static_cast< byte >(val2);
16050 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16051 if (!SWIG_IsOK(ecode3)) {
16052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16053 }
16054 arg3 = static_cast< byte >(val3);
16055 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16056 if (!SWIG_IsOK(ecode4)) {
16057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16058 }
16059 arg4 = static_cast< byte >(val4);
16060 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16061 if (!SWIG_IsOK(ecode5)) {
16062 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16063 }
16064 arg5 = static_cast< byte >(val5);
16065 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16066 if (!SWIG_IsOK(ecode6)) {
16067 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16068 }
16069 arg6 = static_cast< byte >(val6);
16070 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16071 if (!SWIG_IsOK(ecode7)) {
16072 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16073 }
16074 arg7 = static_cast< byte >(val7);
16075 {
16076 PyThreadState* __tstate = wxPyBeginAllowThreads();
16077 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16078 wxPyEndAllowThreads(__tstate);
16079 if (PyErr_Occurred()) SWIG_fail;
16080 }
16081 resultobj = SWIG_Py_Void();
16082 return resultobj;
16083 fail:
16084 return NULL;
16085 }
16086
16087
16088 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16089 PyObject *resultobj = 0;
16090 wxImage *arg1 = (wxImage *) 0 ;
16091 double arg2 = (double) 0.299 ;
16092 double arg3 = (double) 0.587 ;
16093 double arg4 = (double) 0.114 ;
16094 SwigValueWrapper<wxImage > result;
16095 void *argp1 = 0 ;
16096 int res1 = 0 ;
16097 double val2 ;
16098 int ecode2 = 0 ;
16099 double val3 ;
16100 int ecode3 = 0 ;
16101 double val4 ;
16102 int ecode4 = 0 ;
16103 PyObject * obj0 = 0 ;
16104 PyObject * obj1 = 0 ;
16105 PyObject * obj2 = 0 ;
16106 PyObject * obj3 = 0 ;
16107 char * kwnames[] = {
16108 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16109 };
16110
16111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16113 if (!SWIG_IsOK(res1)) {
16114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16115 }
16116 arg1 = reinterpret_cast< wxImage * >(argp1);
16117 if (obj1) {
16118 ecode2 = SWIG_AsVal_double(obj1, &val2);
16119 if (!SWIG_IsOK(ecode2)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16121 }
16122 arg2 = static_cast< double >(val2);
16123 }
16124 if (obj2) {
16125 ecode3 = SWIG_AsVal_double(obj2, &val3);
16126 if (!SWIG_IsOK(ecode3)) {
16127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16128 }
16129 arg3 = static_cast< double >(val3);
16130 }
16131 if (obj3) {
16132 ecode4 = SWIG_AsVal_double(obj3, &val4);
16133 if (!SWIG_IsOK(ecode4)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16135 }
16136 arg4 = static_cast< double >(val4);
16137 }
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16145 return resultobj;
16146 fail:
16147 return NULL;
16148 }
16149
16150
16151 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16152 PyObject *resultobj = 0;
16153 wxImage *arg1 = (wxImage *) 0 ;
16154 byte arg2 ;
16155 byte arg3 ;
16156 byte arg4 ;
16157 SwigValueWrapper<wxImage > result;
16158 void *argp1 = 0 ;
16159 int res1 = 0 ;
16160 unsigned char val2 ;
16161 int ecode2 = 0 ;
16162 unsigned char val3 ;
16163 int ecode3 = 0 ;
16164 unsigned char val4 ;
16165 int ecode4 = 0 ;
16166 PyObject * obj0 = 0 ;
16167 PyObject * obj1 = 0 ;
16168 PyObject * obj2 = 0 ;
16169 PyObject * obj3 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16178 }
16179 arg1 = reinterpret_cast< wxImage * >(argp1);
16180 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16181 if (!SWIG_IsOK(ecode2)) {
16182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16183 }
16184 arg2 = static_cast< byte >(val2);
16185 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16186 if (!SWIG_IsOK(ecode3)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16188 }
16189 arg3 = static_cast< byte >(val3);
16190 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16191 if (!SWIG_IsOK(ecode4)) {
16192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16193 }
16194 arg4 = static_cast< byte >(val4);
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16198 wxPyEndAllowThreads(__tstate);
16199 if (PyErr_Occurred()) SWIG_fail;
16200 }
16201 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16209 PyObject *resultobj = 0;
16210 wxImage *arg1 = (wxImage *) 0 ;
16211 wxString *arg2 = 0 ;
16212 wxString *arg3 = 0 ;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 bool temp2 = false ;
16216 bool temp3 = false ;
16217 PyObject * obj0 = 0 ;
16218 PyObject * obj1 = 0 ;
16219 PyObject * obj2 = 0 ;
16220 char * kwnames[] = {
16221 (char *) "self",(char *) "name",(char *) "value", NULL
16222 };
16223
16224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16226 if (!SWIG_IsOK(res1)) {
16227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16228 }
16229 arg1 = reinterpret_cast< wxImage * >(argp1);
16230 {
16231 arg2 = wxString_in_helper(obj1);
16232 if (arg2 == NULL) SWIG_fail;
16233 temp2 = true;
16234 }
16235 {
16236 arg3 = wxString_in_helper(obj2);
16237 if (arg3 == NULL) SWIG_fail;
16238 temp3 = true;
16239 }
16240 {
16241 PyThreadState* __tstate = wxPyBeginAllowThreads();
16242 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 resultobj = SWIG_Py_Void();
16247 {
16248 if (temp2)
16249 delete arg2;
16250 }
16251 {
16252 if (temp3)
16253 delete arg3;
16254 }
16255 return resultobj;
16256 fail:
16257 {
16258 if (temp2)
16259 delete arg2;
16260 }
16261 {
16262 if (temp3)
16263 delete arg3;
16264 }
16265 return NULL;
16266 }
16267
16268
16269 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16270 PyObject *resultobj = 0;
16271 wxImage *arg1 = (wxImage *) 0 ;
16272 wxString *arg2 = 0 ;
16273 int arg3 ;
16274 void *argp1 = 0 ;
16275 int res1 = 0 ;
16276 bool temp2 = false ;
16277 int val3 ;
16278 int ecode3 = 0 ;
16279 PyObject * obj0 = 0 ;
16280 PyObject * obj1 = 0 ;
16281 PyObject * obj2 = 0 ;
16282 char * kwnames[] = {
16283 (char *) "self",(char *) "name",(char *) "value", NULL
16284 };
16285
16286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16288 if (!SWIG_IsOK(res1)) {
16289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16290 }
16291 arg1 = reinterpret_cast< wxImage * >(argp1);
16292 {
16293 arg2 = wxString_in_helper(obj1);
16294 if (arg2 == NULL) SWIG_fail;
16295 temp2 = true;
16296 }
16297 ecode3 = SWIG_AsVal_int(obj2, &val3);
16298 if (!SWIG_IsOK(ecode3)) {
16299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16300 }
16301 arg3 = static_cast< int >(val3);
16302 {
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 (arg1)->SetOption((wxString const &)*arg2,arg3);
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 resultobj = SWIG_Py_Void();
16309 {
16310 if (temp2)
16311 delete arg2;
16312 }
16313 return resultobj;
16314 fail:
16315 {
16316 if (temp2)
16317 delete arg2;
16318 }
16319 return NULL;
16320 }
16321
16322
16323 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16324 PyObject *resultobj = 0;
16325 wxImage *arg1 = (wxImage *) 0 ;
16326 wxString *arg2 = 0 ;
16327 wxString result;
16328 void *argp1 = 0 ;
16329 int res1 = 0 ;
16330 bool temp2 = false ;
16331 PyObject * obj0 = 0 ;
16332 PyObject * obj1 = 0 ;
16333 char * kwnames[] = {
16334 (char *) "self",(char *) "name", NULL
16335 };
16336
16337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16339 if (!SWIG_IsOK(res1)) {
16340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16341 }
16342 arg1 = reinterpret_cast< wxImage * >(argp1);
16343 {
16344 arg2 = wxString_in_helper(obj1);
16345 if (arg2 == NULL) SWIG_fail;
16346 temp2 = true;
16347 }
16348 {
16349 PyThreadState* __tstate = wxPyBeginAllowThreads();
16350 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16351 wxPyEndAllowThreads(__tstate);
16352 if (PyErr_Occurred()) SWIG_fail;
16353 }
16354 {
16355 #if wxUSE_UNICODE
16356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16357 #else
16358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16359 #endif
16360 }
16361 {
16362 if (temp2)
16363 delete arg2;
16364 }
16365 return resultobj;
16366 fail:
16367 {
16368 if (temp2)
16369 delete arg2;
16370 }
16371 return NULL;
16372 }
16373
16374
16375 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16376 PyObject *resultobj = 0;
16377 wxImage *arg1 = (wxImage *) 0 ;
16378 wxString *arg2 = 0 ;
16379 int result;
16380 void *argp1 = 0 ;
16381 int res1 = 0 ;
16382 bool temp2 = false ;
16383 PyObject * obj0 = 0 ;
16384 PyObject * obj1 = 0 ;
16385 char * kwnames[] = {
16386 (char *) "self",(char *) "name", NULL
16387 };
16388
16389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16391 if (!SWIG_IsOK(res1)) {
16392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16393 }
16394 arg1 = reinterpret_cast< wxImage * >(argp1);
16395 {
16396 arg2 = wxString_in_helper(obj1);
16397 if (arg2 == NULL) SWIG_fail;
16398 temp2 = true;
16399 }
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 resultobj = SWIG_From_int(static_cast< int >(result));
16407 {
16408 if (temp2)
16409 delete arg2;
16410 }
16411 return resultobj;
16412 fail:
16413 {
16414 if (temp2)
16415 delete arg2;
16416 }
16417 return NULL;
16418 }
16419
16420
16421 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj = 0;
16423 wxImage *arg1 = (wxImage *) 0 ;
16424 wxString *arg2 = 0 ;
16425 bool result;
16426 void *argp1 = 0 ;
16427 int res1 = 0 ;
16428 bool temp2 = false ;
16429 PyObject * obj0 = 0 ;
16430 PyObject * obj1 = 0 ;
16431 char * kwnames[] = {
16432 (char *) "self",(char *) "name", NULL
16433 };
16434
16435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16437 if (!SWIG_IsOK(res1)) {
16438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16439 }
16440 arg1 = reinterpret_cast< wxImage * >(argp1);
16441 {
16442 arg2 = wxString_in_helper(obj1);
16443 if (arg2 == NULL) SWIG_fail;
16444 temp2 = true;
16445 }
16446 {
16447 PyThreadState* __tstate = wxPyBeginAllowThreads();
16448 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16449 wxPyEndAllowThreads(__tstate);
16450 if (PyErr_Occurred()) SWIG_fail;
16451 }
16452 {
16453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16454 }
16455 {
16456 if (temp2)
16457 delete arg2;
16458 }
16459 return resultobj;
16460 fail:
16461 {
16462 if (temp2)
16463 delete arg2;
16464 }
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16470 PyObject *resultobj = 0;
16471 wxImage *arg1 = (wxImage *) 0 ;
16472 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16473 unsigned long result;
16474 void *argp1 = 0 ;
16475 int res1 = 0 ;
16476 unsigned long val2 ;
16477 int ecode2 = 0 ;
16478 PyObject * obj0 = 0 ;
16479 PyObject * obj1 = 0 ;
16480 char * kwnames[] = {
16481 (char *) "self",(char *) "stopafter", NULL
16482 };
16483
16484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16486 if (!SWIG_IsOK(res1)) {
16487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16488 }
16489 arg1 = reinterpret_cast< wxImage * >(argp1);
16490 if (obj1) {
16491 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16492 if (!SWIG_IsOK(ecode2)) {
16493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16494 }
16495 arg2 = static_cast< unsigned long >(val2);
16496 }
16497 {
16498 PyThreadState* __tstate = wxPyBeginAllowThreads();
16499 result = (unsigned long)(arg1)->CountColours(arg2);
16500 wxPyEndAllowThreads(__tstate);
16501 if (PyErr_Occurred()) SWIG_fail;
16502 }
16503 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj = 0;
16512 wxImage *arg1 = (wxImage *) 0 ;
16513 wxImageHistogram *arg2 = 0 ;
16514 unsigned long result;
16515 void *argp1 = 0 ;
16516 int res1 = 0 ;
16517 void *argp2 = 0 ;
16518 int res2 = 0 ;
16519 PyObject * obj0 = 0 ;
16520 PyObject * obj1 = 0 ;
16521 char * kwnames[] = {
16522 (char *) "self",(char *) "h", NULL
16523 };
16524
16525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16527 if (!SWIG_IsOK(res1)) {
16528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16529 }
16530 arg1 = reinterpret_cast< wxImage * >(argp1);
16531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16532 if (!SWIG_IsOK(res2)) {
16533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16534 }
16535 if (!argp2) {
16536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16537 }
16538 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16539 {
16540 PyThreadState* __tstate = wxPyBeginAllowThreads();
16541 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16546 return resultobj;
16547 fail:
16548 return NULL;
16549 }
16550
16551
16552 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16553 PyObject *resultobj = 0;
16554 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16555 void *argp1 = 0 ;
16556 int res1 = 0 ;
16557 PyObject * obj0 = 0 ;
16558 char * kwnames[] = {
16559 (char *) "handler", NULL
16560 };
16561
16562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16564 if (!SWIG_IsOK(res1)) {
16565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16566 }
16567 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 wxImage::AddHandler(arg1);
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 resultobj = SWIG_Py_Void();
16575 return resultobj;
16576 fail:
16577 return NULL;
16578 }
16579
16580
16581 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16582 PyObject *resultobj = 0;
16583 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16584 void *argp1 = 0 ;
16585 int res1 = 0 ;
16586 PyObject * obj0 = 0 ;
16587 char * kwnames[] = {
16588 (char *) "handler", NULL
16589 };
16590
16591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16593 if (!SWIG_IsOK(res1)) {
16594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16595 }
16596 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 wxImage::InsertHandler(arg1);
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 resultobj = SWIG_Py_Void();
16604 return resultobj;
16605 fail:
16606 return NULL;
16607 }
16608
16609
16610 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16611 PyObject *resultobj = 0;
16612 wxString *arg1 = 0 ;
16613 bool result;
16614 bool temp1 = false ;
16615 PyObject * obj0 = 0 ;
16616 char * kwnames[] = {
16617 (char *) "name", NULL
16618 };
16619
16620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16621 {
16622 arg1 = wxString_in_helper(obj0);
16623 if (arg1 == NULL) SWIG_fail;
16624 temp1 = true;
16625 }
16626 {
16627 PyThreadState* __tstate = wxPyBeginAllowThreads();
16628 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16629 wxPyEndAllowThreads(__tstate);
16630 if (PyErr_Occurred()) SWIG_fail;
16631 }
16632 {
16633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16634 }
16635 {
16636 if (temp1)
16637 delete arg1;
16638 }
16639 return resultobj;
16640 fail:
16641 {
16642 if (temp1)
16643 delete arg1;
16644 }
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16650 PyObject *resultobj = 0;
16651 PyObject *result = 0 ;
16652
16653 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16654 {
16655 PyThreadState* __tstate = wxPyBeginAllowThreads();
16656 result = (PyObject *)wxImage_GetHandlers();
16657 wxPyEndAllowThreads(__tstate);
16658 if (PyErr_Occurred()) SWIG_fail;
16659 }
16660 resultobj = result;
16661 return resultobj;
16662 fail:
16663 return NULL;
16664 }
16665
16666
16667 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16668 PyObject *resultobj = 0;
16669 wxString result;
16670
16671 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = wxImage::GetImageExtWildcard();
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 {
16679 #if wxUSE_UNICODE
16680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16681 #else
16682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16683 #endif
16684 }
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj = 0;
16693 wxImage *arg1 = (wxImage *) 0 ;
16694 int arg2 = (int) -1 ;
16695 wxBitmap result;
16696 void *argp1 = 0 ;
16697 int res1 = 0 ;
16698 int val2 ;
16699 int ecode2 = 0 ;
16700 PyObject * obj0 = 0 ;
16701 PyObject * obj1 = 0 ;
16702 char * kwnames[] = {
16703 (char *) "self",(char *) "depth", NULL
16704 };
16705
16706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16708 if (!SWIG_IsOK(res1)) {
16709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16710 }
16711 arg1 = reinterpret_cast< wxImage * >(argp1);
16712 if (obj1) {
16713 ecode2 = SWIG_AsVal_int(obj1, &val2);
16714 if (!SWIG_IsOK(ecode2)) {
16715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16716 }
16717 arg2 = static_cast< int >(val2);
16718 }
16719 {
16720 if (!wxPyCheckForApp()) SWIG_fail;
16721 PyThreadState* __tstate = wxPyBeginAllowThreads();
16722 result = wxImage_ConvertToBitmap(arg1,arg2);
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16727 return resultobj;
16728 fail:
16729 return NULL;
16730 }
16731
16732
16733 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16734 PyObject *resultobj = 0;
16735 wxImage *arg1 = (wxImage *) 0 ;
16736 byte arg2 ;
16737 byte arg3 ;
16738 byte arg4 ;
16739 wxBitmap result;
16740 void *argp1 = 0 ;
16741 int res1 = 0 ;
16742 unsigned char val2 ;
16743 int ecode2 = 0 ;
16744 unsigned char val3 ;
16745 int ecode3 = 0 ;
16746 unsigned char val4 ;
16747 int ecode4 = 0 ;
16748 PyObject * obj0 = 0 ;
16749 PyObject * obj1 = 0 ;
16750 PyObject * obj2 = 0 ;
16751 PyObject * obj3 = 0 ;
16752 char * kwnames[] = {
16753 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16754 };
16755
16756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16758 if (!SWIG_IsOK(res1)) {
16759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16760 }
16761 arg1 = reinterpret_cast< wxImage * >(argp1);
16762 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16763 if (!SWIG_IsOK(ecode2)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16765 }
16766 arg2 = static_cast< byte >(val2);
16767 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16768 if (!SWIG_IsOK(ecode3)) {
16769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16770 }
16771 arg3 = static_cast< byte >(val3);
16772 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16773 if (!SWIG_IsOK(ecode4)) {
16774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16775 }
16776 arg4 = static_cast< byte >(val4);
16777 {
16778 if (!wxPyCheckForApp()) SWIG_fail;
16779 PyThreadState* __tstate = wxPyBeginAllowThreads();
16780 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16781 wxPyEndAllowThreads(__tstate);
16782 if (PyErr_Occurred()) SWIG_fail;
16783 }
16784 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16785 return resultobj;
16786 fail:
16787 return NULL;
16788 }
16789
16790
16791 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16792 PyObject *resultobj = 0;
16793 wxImage *arg1 = (wxImage *) 0 ;
16794 double arg2 ;
16795 void *argp1 = 0 ;
16796 int res1 = 0 ;
16797 double val2 ;
16798 int ecode2 = 0 ;
16799 PyObject * obj0 = 0 ;
16800 PyObject * obj1 = 0 ;
16801 char * kwnames[] = {
16802 (char *) "self",(char *) "angle", NULL
16803 };
16804
16805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16807 if (!SWIG_IsOK(res1)) {
16808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16809 }
16810 arg1 = reinterpret_cast< wxImage * >(argp1);
16811 ecode2 = SWIG_AsVal_double(obj1, &val2);
16812 if (!SWIG_IsOK(ecode2)) {
16813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16814 }
16815 arg2 = static_cast< double >(val2);
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 (arg1)->RotateHue(arg2);
16819 wxPyEndAllowThreads(__tstate);
16820 if (PyErr_Occurred()) SWIG_fail;
16821 }
16822 resultobj = SWIG_Py_Void();
16823 return resultobj;
16824 fail:
16825 return NULL;
16826 }
16827
16828
16829 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16830 PyObject *resultobj = 0;
16831 wxImage_RGBValue arg1 ;
16832 wxImage_HSVValue result;
16833 void *argp1 ;
16834 int res1 = 0 ;
16835 PyObject * obj0 = 0 ;
16836 char * kwnames[] = {
16837 (char *) "rgb", NULL
16838 };
16839
16840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16841 {
16842 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16843 if (!SWIG_IsOK(res1)) {
16844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16845 }
16846 if (!argp1) {
16847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16848 } else {
16849 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16850 arg1 = *temp;
16851 if (SWIG_IsNewObj(res1)) delete temp;
16852 }
16853 }
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = wxImage::RGBtoHSV(arg1);
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj = 0;
16869 wxImage_HSVValue arg1 ;
16870 wxImage_RGBValue result;
16871 void *argp1 ;
16872 int res1 = 0 ;
16873 PyObject * obj0 = 0 ;
16874 char * kwnames[] = {
16875 (char *) "hsv", NULL
16876 };
16877
16878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16879 {
16880 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16881 if (!SWIG_IsOK(res1)) {
16882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16883 }
16884 if (!argp1) {
16885 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16886 } else {
16887 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16888 arg1 = *temp;
16889 if (SWIG_IsNewObj(res1)) delete temp;
16890 }
16891 }
16892 {
16893 PyThreadState* __tstate = wxPyBeginAllowThreads();
16894 result = wxImage::HSVtoRGB(arg1);
16895 wxPyEndAllowThreads(__tstate);
16896 if (PyErr_Occurred()) SWIG_fail;
16897 }
16898 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16899 return resultobj;
16900 fail:
16901 return NULL;
16902 }
16903
16904
16905 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16906 PyObject *obj;
16907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16908 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16909 return SWIG_Py_Void();
16910 }
16911
16912 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16913 return SWIG_Python_InitShadowInstance(args);
16914 }
16915
16916 SWIGINTERN int NullImage_set(PyObject *) {
16917 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16918 return 1;
16919 }
16920
16921
16922 SWIGINTERN PyObject *NullImage_get(void) {
16923 PyObject *pyobj = 0;
16924
16925 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16926 return pyobj;
16927 }
16928
16929
16930 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16931 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16932 return 1;
16933 }
16934
16935
16936 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16937 PyObject *pyobj = 0;
16938
16939 {
16940 #if wxUSE_UNICODE
16941 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16942 #else
16943 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16944 #endif
16945 }
16946 return pyobj;
16947 }
16948
16949
16950 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16951 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16952 return 1;
16953 }
16954
16955
16956 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16957 PyObject *pyobj = 0;
16958
16959 {
16960 #if wxUSE_UNICODE
16961 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16962 #else
16963 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16964 #endif
16965 }
16966 return pyobj;
16967 }
16968
16969
16970 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16971 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16972 return 1;
16973 }
16974
16975
16976 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16977 PyObject *pyobj = 0;
16978
16979 {
16980 #if wxUSE_UNICODE
16981 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16982 #else
16983 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16984 #endif
16985 }
16986 return pyobj;
16987 }
16988
16989
16990 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16991 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16992 return 1;
16993 }
16994
16995
16996 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16997 PyObject *pyobj = 0;
16998
16999 {
17000 #if wxUSE_UNICODE
17001 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17002 #else
17003 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17004 #endif
17005 }
17006 return pyobj;
17007 }
17008
17009
17010 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17011 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17012 return 1;
17013 }
17014
17015
17016 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17017 PyObject *pyobj = 0;
17018
17019 {
17020 #if wxUSE_UNICODE
17021 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17022 #else
17023 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17024 #endif
17025 }
17026 return pyobj;
17027 }
17028
17029
17030 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17031 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17032 return 1;
17033 }
17034
17035
17036 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17037 PyObject *pyobj = 0;
17038
17039 {
17040 #if wxUSE_UNICODE
17041 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17042 #else
17043 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17044 #endif
17045 }
17046 return pyobj;
17047 }
17048
17049
17050 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17051 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17052 return 1;
17053 }
17054
17055
17056 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17057 PyObject *pyobj = 0;
17058
17059 {
17060 #if wxUSE_UNICODE
17061 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17062 #else
17063 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17064 #endif
17065 }
17066 return pyobj;
17067 }
17068
17069
17070 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17071 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17072 return 1;
17073 }
17074
17075
17076 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17077 PyObject *pyobj = 0;
17078
17079 {
17080 #if wxUSE_UNICODE
17081 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17082 #else
17083 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17084 #endif
17085 }
17086 return pyobj;
17087 }
17088
17089
17090 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17091 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17092 return 1;
17093 }
17094
17095
17096 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17097 PyObject *pyobj = 0;
17098
17099 {
17100 #if wxUSE_UNICODE
17101 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17102 #else
17103 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17104 #endif
17105 }
17106 return pyobj;
17107 }
17108
17109
17110 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17111 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17112 return 1;
17113 }
17114
17115
17116 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17117 PyObject *pyobj = 0;
17118
17119 {
17120 #if wxUSE_UNICODE
17121 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17122 #else
17123 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17124 #endif
17125 }
17126 return pyobj;
17127 }
17128
17129
17130 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17131 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17132 return 1;
17133 }
17134
17135
17136 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17137 PyObject *pyobj = 0;
17138
17139 {
17140 #if wxUSE_UNICODE
17141 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17142 #else
17143 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17144 #endif
17145 }
17146 return pyobj;
17147 }
17148
17149
17150 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17151 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17152 return 1;
17153 }
17154
17155
17156 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17157 PyObject *pyobj = 0;
17158
17159 {
17160 #if wxUSE_UNICODE
17161 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17162 #else
17163 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17164 #endif
17165 }
17166 return pyobj;
17167 }
17168
17169
17170 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17171 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17172 return 1;
17173 }
17174
17175
17176 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17177 PyObject *pyobj = 0;
17178
17179 {
17180 #if wxUSE_UNICODE
17181 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17182 #else
17183 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17184 #endif
17185 }
17186 return pyobj;
17187 }
17188
17189
17190 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17191 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17192 return 1;
17193 }
17194
17195
17196 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17197 PyObject *pyobj = 0;
17198
17199 {
17200 #if wxUSE_UNICODE
17201 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17202 #else
17203 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17204 #endif
17205 }
17206 return pyobj;
17207 }
17208
17209
17210 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17211 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17212 return 1;
17213 }
17214
17215
17216 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17217 PyObject *pyobj = 0;
17218
17219 {
17220 #if wxUSE_UNICODE
17221 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17222 #else
17223 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17224 #endif
17225 }
17226 return pyobj;
17227 }
17228
17229
17230 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17231 PyObject *resultobj = 0;
17232 wxBMPHandler *result = 0 ;
17233
17234 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17235 {
17236 PyThreadState* __tstate = wxPyBeginAllowThreads();
17237 result = (wxBMPHandler *)new wxBMPHandler();
17238 wxPyEndAllowThreads(__tstate);
17239 if (PyErr_Occurred()) SWIG_fail;
17240 }
17241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17242 return resultobj;
17243 fail:
17244 return NULL;
17245 }
17246
17247
17248 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17249 PyObject *obj;
17250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17251 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17252 return SWIG_Py_Void();
17253 }
17254
17255 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17256 return SWIG_Python_InitShadowInstance(args);
17257 }
17258
17259 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17260 PyObject *resultobj = 0;
17261 wxICOHandler *result = 0 ;
17262
17263 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17264 {
17265 PyThreadState* __tstate = wxPyBeginAllowThreads();
17266 result = (wxICOHandler *)new wxICOHandler();
17267 wxPyEndAllowThreads(__tstate);
17268 if (PyErr_Occurred()) SWIG_fail;
17269 }
17270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17278 PyObject *obj;
17279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17280 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17281 return SWIG_Py_Void();
17282 }
17283
17284 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17285 return SWIG_Python_InitShadowInstance(args);
17286 }
17287
17288 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17289 PyObject *resultobj = 0;
17290 wxCURHandler *result = 0 ;
17291
17292 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17293 {
17294 PyThreadState* __tstate = wxPyBeginAllowThreads();
17295 result = (wxCURHandler *)new wxCURHandler();
17296 wxPyEndAllowThreads(__tstate);
17297 if (PyErr_Occurred()) SWIG_fail;
17298 }
17299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17300 return resultobj;
17301 fail:
17302 return NULL;
17303 }
17304
17305
17306 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17307 PyObject *obj;
17308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17309 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17310 return SWIG_Py_Void();
17311 }
17312
17313 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17314 return SWIG_Python_InitShadowInstance(args);
17315 }
17316
17317 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17318 PyObject *resultobj = 0;
17319 wxANIHandler *result = 0 ;
17320
17321 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17322 {
17323 PyThreadState* __tstate = wxPyBeginAllowThreads();
17324 result = (wxANIHandler *)new wxANIHandler();
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 PyObject *obj;
17337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17338 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17339 return SWIG_Py_Void();
17340 }
17341
17342 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17343 return SWIG_Python_InitShadowInstance(args);
17344 }
17345
17346 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17347 PyObject *resultobj = 0;
17348 wxPNGHandler *result = 0 ;
17349
17350 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (wxPNGHandler *)new wxPNGHandler();
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17358 return resultobj;
17359 fail:
17360 return NULL;
17361 }
17362
17363
17364 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17365 PyObject *obj;
17366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17367 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17368 return SWIG_Py_Void();
17369 }
17370
17371 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17372 return SWIG_Python_InitShadowInstance(args);
17373 }
17374
17375 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17376 PyObject *resultobj = 0;
17377 wxGIFHandler *result = 0 ;
17378
17379 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17380 {
17381 PyThreadState* __tstate = wxPyBeginAllowThreads();
17382 result = (wxGIFHandler *)new wxGIFHandler();
17383 wxPyEndAllowThreads(__tstate);
17384 if (PyErr_Occurred()) SWIG_fail;
17385 }
17386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17387 return resultobj;
17388 fail:
17389 return NULL;
17390 }
17391
17392
17393 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17394 PyObject *obj;
17395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17396 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17397 return SWIG_Py_Void();
17398 }
17399
17400 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17401 return SWIG_Python_InitShadowInstance(args);
17402 }
17403
17404 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17405 PyObject *resultobj = 0;
17406 wxPCXHandler *result = 0 ;
17407
17408 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17409 {
17410 PyThreadState* __tstate = wxPyBeginAllowThreads();
17411 result = (wxPCXHandler *)new wxPCXHandler();
17412 wxPyEndAllowThreads(__tstate);
17413 if (PyErr_Occurred()) SWIG_fail;
17414 }
17415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17416 return resultobj;
17417 fail:
17418 return NULL;
17419 }
17420
17421
17422 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17423 PyObject *obj;
17424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17425 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17426 return SWIG_Py_Void();
17427 }
17428
17429 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17430 return SWIG_Python_InitShadowInstance(args);
17431 }
17432
17433 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17434 PyObject *resultobj = 0;
17435 wxJPEGHandler *result = 0 ;
17436
17437 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17438 {
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (wxJPEGHandler *)new wxJPEGHandler();
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17445 return resultobj;
17446 fail:
17447 return NULL;
17448 }
17449
17450
17451 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17452 PyObject *obj;
17453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17454 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17455 return SWIG_Py_Void();
17456 }
17457
17458 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17459 return SWIG_Python_InitShadowInstance(args);
17460 }
17461
17462 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 PyObject *resultobj = 0;
17464 wxPNMHandler *result = 0 ;
17465
17466 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17467 {
17468 PyThreadState* __tstate = wxPyBeginAllowThreads();
17469 result = (wxPNMHandler *)new wxPNMHandler();
17470 wxPyEndAllowThreads(__tstate);
17471 if (PyErr_Occurred()) SWIG_fail;
17472 }
17473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17474 return resultobj;
17475 fail:
17476 return NULL;
17477 }
17478
17479
17480 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17481 PyObject *obj;
17482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17483 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17484 return SWIG_Py_Void();
17485 }
17486
17487 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17488 return SWIG_Python_InitShadowInstance(args);
17489 }
17490
17491 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17492 PyObject *resultobj = 0;
17493 wxXPMHandler *result = 0 ;
17494
17495 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17496 {
17497 PyThreadState* __tstate = wxPyBeginAllowThreads();
17498 result = (wxXPMHandler *)new wxXPMHandler();
17499 wxPyEndAllowThreads(__tstate);
17500 if (PyErr_Occurred()) SWIG_fail;
17501 }
17502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17503 return resultobj;
17504 fail:
17505 return NULL;
17506 }
17507
17508
17509 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17510 PyObject *obj;
17511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17512 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17513 return SWIG_Py_Void();
17514 }
17515
17516 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17517 return SWIG_Python_InitShadowInstance(args);
17518 }
17519
17520 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17521 PyObject *resultobj = 0;
17522 wxTIFFHandler *result = 0 ;
17523
17524 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (wxTIFFHandler *)new wxTIFFHandler();
17528 wxPyEndAllowThreads(__tstate);
17529 if (PyErr_Occurred()) SWIG_fail;
17530 }
17531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17532 return resultobj;
17533 fail:
17534 return NULL;
17535 }
17536
17537
17538 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17539 PyObject *obj;
17540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17541 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17542 return SWIG_Py_Void();
17543 }
17544
17545 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17546 return SWIG_Python_InitShadowInstance(args);
17547 }
17548
17549 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj = 0;
17551 wxImage *arg1 = 0 ;
17552 wxImage *arg2 = 0 ;
17553 int arg3 = (int) 236 ;
17554 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17555 bool result;
17556 void *argp1 = 0 ;
17557 int res1 = 0 ;
17558 void *argp2 = 0 ;
17559 int res2 = 0 ;
17560 int val3 ;
17561 int ecode3 = 0 ;
17562 int 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 *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17570 };
17571
17572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",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 '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17576 }
17577 if (!argp1) {
17578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17579 }
17580 arg1 = reinterpret_cast< wxImage * >(argp1);
17581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17582 if (!SWIG_IsOK(res2)) {
17583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17584 }
17585 if (!argp2) {
17586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17587 }
17588 arg2 = reinterpret_cast< wxImage * >(argp2);
17589 if (obj2) {
17590 ecode3 = SWIG_AsVal_int(obj2, &val3);
17591 if (!SWIG_IsOK(ecode3)) {
17592 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17593 }
17594 arg3 = static_cast< int >(val3);
17595 }
17596 if (obj3) {
17597 ecode4 = SWIG_AsVal_int(obj3, &val4);
17598 if (!SWIG_IsOK(ecode4)) {
17599 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17600 }
17601 arg4 = static_cast< int >(val4);
17602 }
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17606 wxPyEndAllowThreads(__tstate);
17607 if (PyErr_Occurred()) SWIG_fail;
17608 }
17609 {
17610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17611 }
17612 return resultobj;
17613 fail:
17614 return NULL;
17615 }
17616
17617
17618 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17619 PyObject *obj;
17620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17621 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17622 return SWIG_Py_Void();
17623 }
17624
17625 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17626 PyObject *resultobj = 0;
17627 wxEvtHandler *result = 0 ;
17628
17629 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17630 {
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (wxEvtHandler *)new wxEvtHandler();
17633 wxPyEndAllowThreads(__tstate);
17634 if (PyErr_Occurred()) SWIG_fail;
17635 }
17636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17637 return resultobj;
17638 fail:
17639 return NULL;
17640 }
17641
17642
17643 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17644 PyObject *resultobj = 0;
17645 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17646 wxEvtHandler *result = 0 ;
17647 void *argp1 = 0 ;
17648 int res1 = 0 ;
17649 PyObject *swig_obj[1] ;
17650
17651 if (!args) SWIG_fail;
17652 swig_obj[0] = args;
17653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17654 if (!SWIG_IsOK(res1)) {
17655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17656 }
17657 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17658 {
17659 PyThreadState* __tstate = wxPyBeginAllowThreads();
17660 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17661 wxPyEndAllowThreads(__tstate);
17662 if (PyErr_Occurred()) SWIG_fail;
17663 }
17664 {
17665 resultobj = wxPyMake_wxObject(result, 0);
17666 }
17667 return resultobj;
17668 fail:
17669 return NULL;
17670 }
17671
17672
17673 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17674 PyObject *resultobj = 0;
17675 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17676 wxEvtHandler *result = 0 ;
17677 void *argp1 = 0 ;
17678 int res1 = 0 ;
17679 PyObject *swig_obj[1] ;
17680
17681 if (!args) SWIG_fail;
17682 swig_obj[0] = args;
17683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17684 if (!SWIG_IsOK(res1)) {
17685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17686 }
17687 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17688 {
17689 PyThreadState* __tstate = wxPyBeginAllowThreads();
17690 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 {
17695 resultobj = wxPyMake_wxObject(result, 0);
17696 }
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17704 PyObject *resultobj = 0;
17705 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17706 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17707 void *argp1 = 0 ;
17708 int res1 = 0 ;
17709 void *argp2 = 0 ;
17710 int res2 = 0 ;
17711 PyObject * obj0 = 0 ;
17712 PyObject * obj1 = 0 ;
17713 char * kwnames[] = {
17714 (char *) "self",(char *) "handler", NULL
17715 };
17716
17717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17719 if (!SWIG_IsOK(res1)) {
17720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17721 }
17722 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17724 if (!SWIG_IsOK(res2)) {
17725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17726 }
17727 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17728 {
17729 PyThreadState* __tstate = wxPyBeginAllowThreads();
17730 (arg1)->SetNextHandler(arg2);
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 resultobj = SWIG_Py_Void();
17735 return resultobj;
17736 fail:
17737 return NULL;
17738 }
17739
17740
17741 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17742 PyObject *resultobj = 0;
17743 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17744 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17745 void *argp1 = 0 ;
17746 int res1 = 0 ;
17747 void *argp2 = 0 ;
17748 int res2 = 0 ;
17749 PyObject * obj0 = 0 ;
17750 PyObject * obj1 = 0 ;
17751 char * kwnames[] = {
17752 (char *) "self",(char *) "handler", NULL
17753 };
17754
17755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17757 if (!SWIG_IsOK(res1)) {
17758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17759 }
17760 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17762 if (!SWIG_IsOK(res2)) {
17763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17764 }
17765 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17766 {
17767 PyThreadState* __tstate = wxPyBeginAllowThreads();
17768 (arg1)->SetPreviousHandler(arg2);
17769 wxPyEndAllowThreads(__tstate);
17770 if (PyErr_Occurred()) SWIG_fail;
17771 }
17772 resultobj = SWIG_Py_Void();
17773 return resultobj;
17774 fail:
17775 return NULL;
17776 }
17777
17778
17779 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17780 PyObject *resultobj = 0;
17781 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17782 bool result;
17783 void *argp1 = 0 ;
17784 int res1 = 0 ;
17785 PyObject *swig_obj[1] ;
17786
17787 if (!args) SWIG_fail;
17788 swig_obj[0] = args;
17789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17790 if (!SWIG_IsOK(res1)) {
17791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17792 }
17793 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17794 {
17795 PyThreadState* __tstate = wxPyBeginAllowThreads();
17796 result = (bool)(arg1)->GetEvtHandlerEnabled();
17797 wxPyEndAllowThreads(__tstate);
17798 if (PyErr_Occurred()) SWIG_fail;
17799 }
17800 {
17801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17802 }
17803 return resultobj;
17804 fail:
17805 return NULL;
17806 }
17807
17808
17809 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj = 0;
17811 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17812 bool arg2 ;
17813 void *argp1 = 0 ;
17814 int res1 = 0 ;
17815 bool val2 ;
17816 int ecode2 = 0 ;
17817 PyObject * obj0 = 0 ;
17818 PyObject * obj1 = 0 ;
17819 char * kwnames[] = {
17820 (char *) "self",(char *) "enabled", NULL
17821 };
17822
17823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17825 if (!SWIG_IsOK(res1)) {
17826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17827 }
17828 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17830 if (!SWIG_IsOK(ecode2)) {
17831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17832 }
17833 arg2 = static_cast< bool >(val2);
17834 {
17835 PyThreadState* __tstate = wxPyBeginAllowThreads();
17836 (arg1)->SetEvtHandlerEnabled(arg2);
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 resultobj = SWIG_Py_Void();
17841 return resultobj;
17842 fail:
17843 return NULL;
17844 }
17845
17846
17847 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17848 PyObject *resultobj = 0;
17849 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17850 wxEvent *arg2 = 0 ;
17851 bool result;
17852 void *argp1 = 0 ;
17853 int res1 = 0 ;
17854 void *argp2 = 0 ;
17855 int res2 = 0 ;
17856 PyObject * obj0 = 0 ;
17857 PyObject * obj1 = 0 ;
17858 char * kwnames[] = {
17859 (char *) "self",(char *) "event", NULL
17860 };
17861
17862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17864 if (!SWIG_IsOK(res1)) {
17865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17866 }
17867 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17868 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17869 if (!SWIG_IsOK(res2)) {
17870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17871 }
17872 if (!argp2) {
17873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17874 }
17875 arg2 = reinterpret_cast< wxEvent * >(argp2);
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 result = (bool)(arg1)->ProcessEvent(*arg2);
17879 wxPyEndAllowThreads(__tstate);
17880 if (PyErr_Occurred()) SWIG_fail;
17881 }
17882 {
17883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17884 }
17885 return resultobj;
17886 fail:
17887 return NULL;
17888 }
17889
17890
17891 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17892 PyObject *resultobj = 0;
17893 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17894 wxEvent *arg2 = 0 ;
17895 void *argp1 = 0 ;
17896 int res1 = 0 ;
17897 void *argp2 = 0 ;
17898 int res2 = 0 ;
17899 PyObject * obj0 = 0 ;
17900 PyObject * obj1 = 0 ;
17901 char * kwnames[] = {
17902 (char *) "self",(char *) "event", NULL
17903 };
17904
17905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17907 if (!SWIG_IsOK(res1)) {
17908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17909 }
17910 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17911 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17912 if (!SWIG_IsOK(res2)) {
17913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17914 }
17915 if (!argp2) {
17916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17917 }
17918 arg2 = reinterpret_cast< wxEvent * >(argp2);
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 (arg1)->AddPendingEvent(*arg2);
17922 wxPyEndAllowThreads(__tstate);
17923 if (PyErr_Occurred()) SWIG_fail;
17924 }
17925 resultobj = SWIG_Py_Void();
17926 return resultobj;
17927 fail:
17928 return NULL;
17929 }
17930
17931
17932 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17933 PyObject *resultobj = 0;
17934 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17935 void *argp1 = 0 ;
17936 int res1 = 0 ;
17937 PyObject *swig_obj[1] ;
17938
17939 if (!args) SWIG_fail;
17940 swig_obj[0] = args;
17941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17942 if (!SWIG_IsOK(res1)) {
17943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17944 }
17945 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17946 {
17947 PyThreadState* __tstate = wxPyBeginAllowThreads();
17948 (arg1)->ProcessPendingEvents();
17949 wxPyEndAllowThreads(__tstate);
17950 if (PyErr_Occurred()) SWIG_fail;
17951 }
17952 resultobj = SWIG_Py_Void();
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj = 0;
17961 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17962 int arg2 ;
17963 int arg3 ;
17964 int arg4 ;
17965 PyObject *arg5 = (PyObject *) 0 ;
17966 void *argp1 = 0 ;
17967 int res1 = 0 ;
17968 int val2 ;
17969 int ecode2 = 0 ;
17970 int val3 ;
17971 int ecode3 = 0 ;
17972 int val4 ;
17973 int ecode4 = 0 ;
17974 PyObject * obj0 = 0 ;
17975 PyObject * obj1 = 0 ;
17976 PyObject * obj2 = 0 ;
17977 PyObject * obj3 = 0 ;
17978 PyObject * obj4 = 0 ;
17979 char * kwnames[] = {
17980 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17981 };
17982
17983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17985 if (!SWIG_IsOK(res1)) {
17986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17987 }
17988 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17989 ecode2 = SWIG_AsVal_int(obj1, &val2);
17990 if (!SWIG_IsOK(ecode2)) {
17991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17992 }
17993 arg2 = static_cast< int >(val2);
17994 ecode3 = SWIG_AsVal_int(obj2, &val3);
17995 if (!SWIG_IsOK(ecode3)) {
17996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17997 }
17998 arg3 = static_cast< int >(val3);
17999 ecode4 = SWIG_AsVal_int(obj3, &val4);
18000 if (!SWIG_IsOK(ecode4)) {
18001 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18002 }
18003 arg4 = static_cast< int >(val4);
18004 arg5 = obj4;
18005 {
18006 PyThreadState* __tstate = wxPyBeginAllowThreads();
18007 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18008 wxPyEndAllowThreads(__tstate);
18009 if (PyErr_Occurred()) SWIG_fail;
18010 }
18011 resultobj = SWIG_Py_Void();
18012 return resultobj;
18013 fail:
18014 return NULL;
18015 }
18016
18017
18018 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18019 PyObject *resultobj = 0;
18020 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18021 int arg2 ;
18022 int arg3 = (int) -1 ;
18023 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18024 bool result;
18025 void *argp1 = 0 ;
18026 int res1 = 0 ;
18027 int val2 ;
18028 int ecode2 = 0 ;
18029 int val3 ;
18030 int ecode3 = 0 ;
18031 int val4 ;
18032 int ecode4 = 0 ;
18033 PyObject * obj0 = 0 ;
18034 PyObject * obj1 = 0 ;
18035 PyObject * obj2 = 0 ;
18036 PyObject * obj3 = 0 ;
18037 char * kwnames[] = {
18038 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18039 };
18040
18041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18043 if (!SWIG_IsOK(res1)) {
18044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18045 }
18046 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18047 ecode2 = SWIG_AsVal_int(obj1, &val2);
18048 if (!SWIG_IsOK(ecode2)) {
18049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18050 }
18051 arg2 = static_cast< int >(val2);
18052 if (obj2) {
18053 ecode3 = SWIG_AsVal_int(obj2, &val3);
18054 if (!SWIG_IsOK(ecode3)) {
18055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18056 }
18057 arg3 = static_cast< int >(val3);
18058 }
18059 if (obj3) {
18060 ecode4 = SWIG_AsVal_int(obj3, &val4);
18061 if (!SWIG_IsOK(ecode4)) {
18062 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18063 }
18064 arg4 = static_cast< wxEventType >(val4);
18065 }
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 {
18073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18074 }
18075 return resultobj;
18076 fail:
18077 return NULL;
18078 }
18079
18080
18081 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj = 0;
18083 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18084 PyObject *arg2 = (PyObject *) 0 ;
18085 bool arg3 = (bool) true ;
18086 void *argp1 = 0 ;
18087 int res1 = 0 ;
18088 bool val3 ;
18089 int ecode3 = 0 ;
18090 PyObject * obj0 = 0 ;
18091 PyObject * obj1 = 0 ;
18092 PyObject * obj2 = 0 ;
18093 char * kwnames[] = {
18094 (char *) "self",(char *) "_self",(char *) "incref", NULL
18095 };
18096
18097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18099 if (!SWIG_IsOK(res1)) {
18100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18101 }
18102 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18103 arg2 = obj1;
18104 if (obj2) {
18105 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18106 if (!SWIG_IsOK(ecode3)) {
18107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18108 }
18109 arg3 = static_cast< bool >(val3);
18110 }
18111 {
18112 PyThreadState* __tstate = wxPyBeginAllowThreads();
18113 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18114 wxPyEndAllowThreads(__tstate);
18115 if (PyErr_Occurred()) SWIG_fail;
18116 }
18117 resultobj = SWIG_Py_Void();
18118 return resultobj;
18119 fail:
18120 return NULL;
18121 }
18122
18123
18124 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18125 PyObject *obj;
18126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18127 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18128 return SWIG_Py_Void();
18129 }
18130
18131 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18132 return SWIG_Python_InitShadowInstance(args);
18133 }
18134
18135 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *resultobj = 0;
18137 wxEventType result;
18138
18139 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 result = (wxEventType)wxNewEventType();
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 resultobj = SWIG_From_int(static_cast< int >(result));
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18154 PyObject *resultobj = 0;
18155 wxEvent *arg1 = (wxEvent *) 0 ;
18156 void *argp1 = 0 ;
18157 int res1 = 0 ;
18158 PyObject *swig_obj[1] ;
18159
18160 if (!args) SWIG_fail;
18161 swig_obj[0] = args;
18162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18163 if (!SWIG_IsOK(res1)) {
18164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18165 }
18166 arg1 = reinterpret_cast< wxEvent * >(argp1);
18167 {
18168 PyThreadState* __tstate = wxPyBeginAllowThreads();
18169 delete arg1;
18170
18171 wxPyEndAllowThreads(__tstate);
18172 if (PyErr_Occurred()) SWIG_fail;
18173 }
18174 resultobj = SWIG_Py_Void();
18175 return resultobj;
18176 fail:
18177 return NULL;
18178 }
18179
18180
18181 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18182 PyObject *resultobj = 0;
18183 wxEvent *arg1 = (wxEvent *) 0 ;
18184 wxEventType arg2 ;
18185 void *argp1 = 0 ;
18186 int res1 = 0 ;
18187 int val2 ;
18188 int ecode2 = 0 ;
18189 PyObject * obj0 = 0 ;
18190 PyObject * obj1 = 0 ;
18191 char * kwnames[] = {
18192 (char *) "self",(char *) "typ", NULL
18193 };
18194
18195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18197 if (!SWIG_IsOK(res1)) {
18198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18199 }
18200 arg1 = reinterpret_cast< wxEvent * >(argp1);
18201 ecode2 = SWIG_AsVal_int(obj1, &val2);
18202 if (!SWIG_IsOK(ecode2)) {
18203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18204 }
18205 arg2 = static_cast< wxEventType >(val2);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 (arg1)->SetEventType(arg2);
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 resultobj = SWIG_Py_Void();
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18220 PyObject *resultobj = 0;
18221 wxEvent *arg1 = (wxEvent *) 0 ;
18222 wxEventType result;
18223 void *argp1 = 0 ;
18224 int res1 = 0 ;
18225 PyObject *swig_obj[1] ;
18226
18227 if (!args) SWIG_fail;
18228 swig_obj[0] = args;
18229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18230 if (!SWIG_IsOK(res1)) {
18231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18232 }
18233 arg1 = reinterpret_cast< wxEvent * >(argp1);
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 resultobj = SWIG_From_int(static_cast< int >(result));
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18248 PyObject *resultobj = 0;
18249 wxEvent *arg1 = (wxEvent *) 0 ;
18250 wxObject *result = 0 ;
18251 void *argp1 = 0 ;
18252 int res1 = 0 ;
18253 PyObject *swig_obj[1] ;
18254
18255 if (!args) SWIG_fail;
18256 swig_obj[0] = args;
18257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18258 if (!SWIG_IsOK(res1)) {
18259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18260 }
18261 arg1 = reinterpret_cast< wxEvent * >(argp1);
18262 {
18263 PyThreadState* __tstate = wxPyBeginAllowThreads();
18264 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18265 wxPyEndAllowThreads(__tstate);
18266 if (PyErr_Occurred()) SWIG_fail;
18267 }
18268 {
18269 resultobj = wxPyMake_wxObject(result, (bool)0);
18270 }
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18278 PyObject *resultobj = 0;
18279 wxEvent *arg1 = (wxEvent *) 0 ;
18280 wxObject *arg2 = (wxObject *) 0 ;
18281 void *argp1 = 0 ;
18282 int res1 = 0 ;
18283 void *argp2 = 0 ;
18284 int res2 = 0 ;
18285 PyObject * obj0 = 0 ;
18286 PyObject * obj1 = 0 ;
18287 char * kwnames[] = {
18288 (char *) "self",(char *) "obj", NULL
18289 };
18290
18291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18295 }
18296 arg1 = reinterpret_cast< wxEvent * >(argp1);
18297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18298 if (!SWIG_IsOK(res2)) {
18299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18300 }
18301 arg2 = reinterpret_cast< wxObject * >(argp2);
18302 {
18303 PyThreadState* __tstate = wxPyBeginAllowThreads();
18304 (arg1)->SetEventObject(arg2);
18305 wxPyEndAllowThreads(__tstate);
18306 if (PyErr_Occurred()) SWIG_fail;
18307 }
18308 resultobj = SWIG_Py_Void();
18309 return resultobj;
18310 fail:
18311 return NULL;
18312 }
18313
18314
18315 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18316 PyObject *resultobj = 0;
18317 wxEvent *arg1 = (wxEvent *) 0 ;
18318 long result;
18319 void *argp1 = 0 ;
18320 int res1 = 0 ;
18321 PyObject *swig_obj[1] ;
18322
18323 if (!args) SWIG_fail;
18324 swig_obj[0] = args;
18325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18326 if (!SWIG_IsOK(res1)) {
18327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18328 }
18329 arg1 = reinterpret_cast< wxEvent * >(argp1);
18330 {
18331 PyThreadState* __tstate = wxPyBeginAllowThreads();
18332 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18333 wxPyEndAllowThreads(__tstate);
18334 if (PyErr_Occurred()) SWIG_fail;
18335 }
18336 resultobj = SWIG_From_long(static_cast< long >(result));
18337 return resultobj;
18338 fail:
18339 return NULL;
18340 }
18341
18342
18343 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18344 PyObject *resultobj = 0;
18345 wxEvent *arg1 = (wxEvent *) 0 ;
18346 long arg2 = (long) 0 ;
18347 void *argp1 = 0 ;
18348 int res1 = 0 ;
18349 long val2 ;
18350 int ecode2 = 0 ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 char * kwnames[] = {
18354 (char *) "self",(char *) "ts", NULL
18355 };
18356
18357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18359 if (!SWIG_IsOK(res1)) {
18360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18361 }
18362 arg1 = reinterpret_cast< wxEvent * >(argp1);
18363 if (obj1) {
18364 ecode2 = SWIG_AsVal_long(obj1, &val2);
18365 if (!SWIG_IsOK(ecode2)) {
18366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18367 }
18368 arg2 = static_cast< long >(val2);
18369 }
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 (arg1)->SetTimestamp(arg2);
18373 wxPyEndAllowThreads(__tstate);
18374 if (PyErr_Occurred()) SWIG_fail;
18375 }
18376 resultobj = SWIG_Py_Void();
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18384 PyObject *resultobj = 0;
18385 wxEvent *arg1 = (wxEvent *) 0 ;
18386 int result;
18387 void *argp1 = 0 ;
18388 int res1 = 0 ;
18389 PyObject *swig_obj[1] ;
18390
18391 if (!args) SWIG_fail;
18392 swig_obj[0] = args;
18393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18394 if (!SWIG_IsOK(res1)) {
18395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18396 }
18397 arg1 = reinterpret_cast< wxEvent * >(argp1);
18398 {
18399 PyThreadState* __tstate = wxPyBeginAllowThreads();
18400 result = (int)((wxEvent const *)arg1)->GetId();
18401 wxPyEndAllowThreads(__tstate);
18402 if (PyErr_Occurred()) SWIG_fail;
18403 }
18404 resultobj = SWIG_From_int(static_cast< int >(result));
18405 return resultobj;
18406 fail:
18407 return NULL;
18408 }
18409
18410
18411 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18412 PyObject *resultobj = 0;
18413 wxEvent *arg1 = (wxEvent *) 0 ;
18414 int arg2 ;
18415 void *argp1 = 0 ;
18416 int res1 = 0 ;
18417 int val2 ;
18418 int ecode2 = 0 ;
18419 PyObject * obj0 = 0 ;
18420 PyObject * obj1 = 0 ;
18421 char * kwnames[] = {
18422 (char *) "self",(char *) "Id", NULL
18423 };
18424
18425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18427 if (!SWIG_IsOK(res1)) {
18428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18429 }
18430 arg1 = reinterpret_cast< wxEvent * >(argp1);
18431 ecode2 = SWIG_AsVal_int(obj1, &val2);
18432 if (!SWIG_IsOK(ecode2)) {
18433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18434 }
18435 arg2 = static_cast< int >(val2);
18436 {
18437 PyThreadState* __tstate = wxPyBeginAllowThreads();
18438 (arg1)->SetId(arg2);
18439 wxPyEndAllowThreads(__tstate);
18440 if (PyErr_Occurred()) SWIG_fail;
18441 }
18442 resultobj = SWIG_Py_Void();
18443 return resultobj;
18444 fail:
18445 return NULL;
18446 }
18447
18448
18449 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18450 PyObject *resultobj = 0;
18451 wxEvent *arg1 = (wxEvent *) 0 ;
18452 bool result;
18453 void *argp1 = 0 ;
18454 int res1 = 0 ;
18455 PyObject *swig_obj[1] ;
18456
18457 if (!args) SWIG_fail;
18458 swig_obj[0] = args;
18459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18460 if (!SWIG_IsOK(res1)) {
18461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18462 }
18463 arg1 = reinterpret_cast< wxEvent * >(argp1);
18464 {
18465 PyThreadState* __tstate = wxPyBeginAllowThreads();
18466 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18467 wxPyEndAllowThreads(__tstate);
18468 if (PyErr_Occurred()) SWIG_fail;
18469 }
18470 {
18471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18472 }
18473 return resultobj;
18474 fail:
18475 return NULL;
18476 }
18477
18478
18479 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18480 PyObject *resultobj = 0;
18481 wxEvent *arg1 = (wxEvent *) 0 ;
18482 bool arg2 = (bool) true ;
18483 void *argp1 = 0 ;
18484 int res1 = 0 ;
18485 bool val2 ;
18486 int ecode2 = 0 ;
18487 PyObject * obj0 = 0 ;
18488 PyObject * obj1 = 0 ;
18489 char * kwnames[] = {
18490 (char *) "self",(char *) "skip", NULL
18491 };
18492
18493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18495 if (!SWIG_IsOK(res1)) {
18496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18497 }
18498 arg1 = reinterpret_cast< wxEvent * >(argp1);
18499 if (obj1) {
18500 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18501 if (!SWIG_IsOK(ecode2)) {
18502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18503 }
18504 arg2 = static_cast< bool >(val2);
18505 }
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 (arg1)->Skip(arg2);
18509 wxPyEndAllowThreads(__tstate);
18510 if (PyErr_Occurred()) SWIG_fail;
18511 }
18512 resultobj = SWIG_Py_Void();
18513 return resultobj;
18514 fail:
18515 return NULL;
18516 }
18517
18518
18519 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18520 PyObject *resultobj = 0;
18521 wxEvent *arg1 = (wxEvent *) 0 ;
18522 bool result;
18523 void *argp1 = 0 ;
18524 int res1 = 0 ;
18525 PyObject *swig_obj[1] ;
18526
18527 if (!args) SWIG_fail;
18528 swig_obj[0] = args;
18529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18530 if (!SWIG_IsOK(res1)) {
18531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18532 }
18533 arg1 = reinterpret_cast< wxEvent * >(argp1);
18534 {
18535 PyThreadState* __tstate = wxPyBeginAllowThreads();
18536 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18537 wxPyEndAllowThreads(__tstate);
18538 if (PyErr_Occurred()) SWIG_fail;
18539 }
18540 {
18541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18542 }
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18550 PyObject *resultobj = 0;
18551 wxEvent *arg1 = (wxEvent *) 0 ;
18552 bool result;
18553 void *argp1 = 0 ;
18554 int res1 = 0 ;
18555 PyObject *swig_obj[1] ;
18556
18557 if (!args) SWIG_fail;
18558 swig_obj[0] = args;
18559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18560 if (!SWIG_IsOK(res1)) {
18561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18562 }
18563 arg1 = reinterpret_cast< wxEvent * >(argp1);
18564 {
18565 PyThreadState* __tstate = wxPyBeginAllowThreads();
18566 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18567 wxPyEndAllowThreads(__tstate);
18568 if (PyErr_Occurred()) SWIG_fail;
18569 }
18570 {
18571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18572 }
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18580 PyObject *resultobj = 0;
18581 wxEvent *arg1 = (wxEvent *) 0 ;
18582 int result;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 PyObject *swig_obj[1] ;
18586
18587 if (!args) SWIG_fail;
18588 swig_obj[0] = args;
18589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18590 if (!SWIG_IsOK(res1)) {
18591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18592 }
18593 arg1 = reinterpret_cast< wxEvent * >(argp1);
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (int)(arg1)->StopPropagation();
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 resultobj = SWIG_From_int(static_cast< int >(result));
18601 return resultobj;
18602 fail:
18603 return NULL;
18604 }
18605
18606
18607 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18608 PyObject *resultobj = 0;
18609 wxEvent *arg1 = (wxEvent *) 0 ;
18610 int arg2 ;
18611 void *argp1 = 0 ;
18612 int res1 = 0 ;
18613 int val2 ;
18614 int ecode2 = 0 ;
18615 PyObject * obj0 = 0 ;
18616 PyObject * obj1 = 0 ;
18617 char * kwnames[] = {
18618 (char *) "self",(char *) "propagationLevel", NULL
18619 };
18620
18621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18625 }
18626 arg1 = reinterpret_cast< wxEvent * >(argp1);
18627 ecode2 = SWIG_AsVal_int(obj1, &val2);
18628 if (!SWIG_IsOK(ecode2)) {
18629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18630 }
18631 arg2 = static_cast< int >(val2);
18632 {
18633 PyThreadState* __tstate = wxPyBeginAllowThreads();
18634 (arg1)->ResumePropagation(arg2);
18635 wxPyEndAllowThreads(__tstate);
18636 if (PyErr_Occurred()) SWIG_fail;
18637 }
18638 resultobj = SWIG_Py_Void();
18639 return resultobj;
18640 fail:
18641 return NULL;
18642 }
18643
18644
18645 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18646 PyObject *resultobj = 0;
18647 wxEvent *arg1 = (wxEvent *) 0 ;
18648 wxEvent *result = 0 ;
18649 void *argp1 = 0 ;
18650 int res1 = 0 ;
18651 PyObject *swig_obj[1] ;
18652
18653 if (!args) SWIG_fail;
18654 swig_obj[0] = args;
18655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18656 if (!SWIG_IsOK(res1)) {
18657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18658 }
18659 arg1 = reinterpret_cast< wxEvent * >(argp1);
18660 {
18661 PyThreadState* __tstate = wxPyBeginAllowThreads();
18662 result = (wxEvent *)(arg1)->Clone();
18663 wxPyEndAllowThreads(__tstate);
18664 if (PyErr_Occurred()) SWIG_fail;
18665 }
18666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18667 return resultobj;
18668 fail:
18669 return NULL;
18670 }
18671
18672
18673 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18674 PyObject *obj;
18675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18676 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18677 return SWIG_Py_Void();
18678 }
18679
18680 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj = 0;
18682 wxEvent *arg1 = 0 ;
18683 wxPropagationDisabler *result = 0 ;
18684 void *argp1 = 0 ;
18685 int res1 = 0 ;
18686 PyObject * obj0 = 0 ;
18687 char * kwnames[] = {
18688 (char *) "event", NULL
18689 };
18690
18691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18692 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18693 if (!SWIG_IsOK(res1)) {
18694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18695 }
18696 if (!argp1) {
18697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18698 }
18699 arg1 = reinterpret_cast< wxEvent * >(argp1);
18700 {
18701 PyThreadState* __tstate = wxPyBeginAllowThreads();
18702 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18703 wxPyEndAllowThreads(__tstate);
18704 if (PyErr_Occurred()) SWIG_fail;
18705 }
18706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18707 return resultobj;
18708 fail:
18709 return NULL;
18710 }
18711
18712
18713 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18714 PyObject *resultobj = 0;
18715 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18716 void *argp1 = 0 ;
18717 int res1 = 0 ;
18718 PyObject *swig_obj[1] ;
18719
18720 if (!args) SWIG_fail;
18721 swig_obj[0] = args;
18722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18723 if (!SWIG_IsOK(res1)) {
18724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18725 }
18726 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18727 {
18728 PyThreadState* __tstate = wxPyBeginAllowThreads();
18729 delete arg1;
18730
18731 wxPyEndAllowThreads(__tstate);
18732 if (PyErr_Occurred()) SWIG_fail;
18733 }
18734 resultobj = SWIG_Py_Void();
18735 return resultobj;
18736 fail:
18737 return NULL;
18738 }
18739
18740
18741 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18742 PyObject *obj;
18743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18744 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18745 return SWIG_Py_Void();
18746 }
18747
18748 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18749 return SWIG_Python_InitShadowInstance(args);
18750 }
18751
18752 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18753 PyObject *resultobj = 0;
18754 wxEvent *arg1 = 0 ;
18755 wxPropagateOnce *result = 0 ;
18756 void *argp1 = 0 ;
18757 int res1 = 0 ;
18758 PyObject * obj0 = 0 ;
18759 char * kwnames[] = {
18760 (char *) "event", NULL
18761 };
18762
18763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18764 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18765 if (!SWIG_IsOK(res1)) {
18766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18767 }
18768 if (!argp1) {
18769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18770 }
18771 arg1 = reinterpret_cast< wxEvent * >(argp1);
18772 {
18773 PyThreadState* __tstate = wxPyBeginAllowThreads();
18774 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18775 wxPyEndAllowThreads(__tstate);
18776 if (PyErr_Occurred()) SWIG_fail;
18777 }
18778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18779 return resultobj;
18780 fail:
18781 return NULL;
18782 }
18783
18784
18785 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18786 PyObject *resultobj = 0;
18787 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18788 void *argp1 = 0 ;
18789 int res1 = 0 ;
18790 PyObject *swig_obj[1] ;
18791
18792 if (!args) SWIG_fail;
18793 swig_obj[0] = args;
18794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18795 if (!SWIG_IsOK(res1)) {
18796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18797 }
18798 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18799 {
18800 PyThreadState* __tstate = wxPyBeginAllowThreads();
18801 delete arg1;
18802
18803 wxPyEndAllowThreads(__tstate);
18804 if (PyErr_Occurred()) SWIG_fail;
18805 }
18806 resultobj = SWIG_Py_Void();
18807 return resultobj;
18808 fail:
18809 return NULL;
18810 }
18811
18812
18813 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18814 PyObject *obj;
18815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18816 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18817 return SWIG_Py_Void();
18818 }
18819
18820 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18821 return SWIG_Python_InitShadowInstance(args);
18822 }
18823
18824 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18825 PyObject *resultobj = 0;
18826 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18827 int arg2 = (int) 0 ;
18828 wxCommandEvent *result = 0 ;
18829 int val1 ;
18830 int ecode1 = 0 ;
18831 int val2 ;
18832 int ecode2 = 0 ;
18833 PyObject * obj0 = 0 ;
18834 PyObject * obj1 = 0 ;
18835 char * kwnames[] = {
18836 (char *) "commandType",(char *) "winid", NULL
18837 };
18838
18839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18840 if (obj0) {
18841 ecode1 = SWIG_AsVal_int(obj0, &val1);
18842 if (!SWIG_IsOK(ecode1)) {
18843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18844 }
18845 arg1 = static_cast< wxEventType >(val1);
18846 }
18847 if (obj1) {
18848 ecode2 = SWIG_AsVal_int(obj1, &val2);
18849 if (!SWIG_IsOK(ecode2)) {
18850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18851 }
18852 arg2 = static_cast< int >(val2);
18853 }
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18857 wxPyEndAllowThreads(__tstate);
18858 if (PyErr_Occurred()) SWIG_fail;
18859 }
18860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18861 return resultobj;
18862 fail:
18863 return NULL;
18864 }
18865
18866
18867 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18868 PyObject *resultobj = 0;
18869 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18870 int result;
18871 void *argp1 = 0 ;
18872 int res1 = 0 ;
18873 PyObject *swig_obj[1] ;
18874
18875 if (!args) SWIG_fail;
18876 swig_obj[0] = args;
18877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18878 if (!SWIG_IsOK(res1)) {
18879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18880 }
18881 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18882 {
18883 PyThreadState* __tstate = wxPyBeginAllowThreads();
18884 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18885 wxPyEndAllowThreads(__tstate);
18886 if (PyErr_Occurred()) SWIG_fail;
18887 }
18888 resultobj = SWIG_From_int(static_cast< int >(result));
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj = 0;
18897 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18898 wxString *arg2 = 0 ;
18899 void *argp1 = 0 ;
18900 int res1 = 0 ;
18901 bool temp2 = false ;
18902 PyObject * obj0 = 0 ;
18903 PyObject * obj1 = 0 ;
18904 char * kwnames[] = {
18905 (char *) "self",(char *) "s", NULL
18906 };
18907
18908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18910 if (!SWIG_IsOK(res1)) {
18911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18912 }
18913 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18914 {
18915 arg2 = wxString_in_helper(obj1);
18916 if (arg2 == NULL) SWIG_fail;
18917 temp2 = true;
18918 }
18919 {
18920 PyThreadState* __tstate = wxPyBeginAllowThreads();
18921 (arg1)->SetString((wxString const &)*arg2);
18922 wxPyEndAllowThreads(__tstate);
18923 if (PyErr_Occurred()) SWIG_fail;
18924 }
18925 resultobj = SWIG_Py_Void();
18926 {
18927 if (temp2)
18928 delete arg2;
18929 }
18930 return resultobj;
18931 fail:
18932 {
18933 if (temp2)
18934 delete arg2;
18935 }
18936 return NULL;
18937 }
18938
18939
18940 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18941 PyObject *resultobj = 0;
18942 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18943 wxString result;
18944 void *argp1 = 0 ;
18945 int res1 = 0 ;
18946 PyObject *swig_obj[1] ;
18947
18948 if (!args) SWIG_fail;
18949 swig_obj[0] = args;
18950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18951 if (!SWIG_IsOK(res1)) {
18952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18953 }
18954 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18955 {
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 result = ((wxCommandEvent const *)arg1)->GetString();
18958 wxPyEndAllowThreads(__tstate);
18959 if (PyErr_Occurred()) SWIG_fail;
18960 }
18961 {
18962 #if wxUSE_UNICODE
18963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18964 #else
18965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18966 #endif
18967 }
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18975 PyObject *resultobj = 0;
18976 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18977 bool result;
18978 void *argp1 = 0 ;
18979 int res1 = 0 ;
18980 PyObject *swig_obj[1] ;
18981
18982 if (!args) SWIG_fail;
18983 swig_obj[0] = args;
18984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18985 if (!SWIG_IsOK(res1)) {
18986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18987 }
18988 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18989 {
18990 PyThreadState* __tstate = wxPyBeginAllowThreads();
18991 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18992 wxPyEndAllowThreads(__tstate);
18993 if (PyErr_Occurred()) SWIG_fail;
18994 }
18995 {
18996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18997 }
18998 return resultobj;
18999 fail:
19000 return NULL;
19001 }
19002
19003
19004 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19005 PyObject *resultobj = 0;
19006 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19007 bool result;
19008 void *argp1 = 0 ;
19009 int res1 = 0 ;
19010 PyObject *swig_obj[1] ;
19011
19012 if (!args) SWIG_fail;
19013 swig_obj[0] = args;
19014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19015 if (!SWIG_IsOK(res1)) {
19016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19017 }
19018 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 {
19026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19027 }
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj = 0;
19036 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19037 long arg2 ;
19038 void *argp1 = 0 ;
19039 int res1 = 0 ;
19040 long val2 ;
19041 int ecode2 = 0 ;
19042 PyObject * obj0 = 0 ;
19043 PyObject * obj1 = 0 ;
19044 char * kwnames[] = {
19045 (char *) "self",(char *) "extraLong", NULL
19046 };
19047
19048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19050 if (!SWIG_IsOK(res1)) {
19051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19052 }
19053 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19054 ecode2 = SWIG_AsVal_long(obj1, &val2);
19055 if (!SWIG_IsOK(ecode2)) {
19056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19057 }
19058 arg2 = static_cast< long >(val2);
19059 {
19060 PyThreadState* __tstate = wxPyBeginAllowThreads();
19061 (arg1)->SetExtraLong(arg2);
19062 wxPyEndAllowThreads(__tstate);
19063 if (PyErr_Occurred()) SWIG_fail;
19064 }
19065 resultobj = SWIG_Py_Void();
19066 return resultobj;
19067 fail:
19068 return NULL;
19069 }
19070
19071
19072 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19073 PyObject *resultobj = 0;
19074 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19075 long result;
19076 void *argp1 = 0 ;
19077 int res1 = 0 ;
19078 PyObject *swig_obj[1] ;
19079
19080 if (!args) SWIG_fail;
19081 swig_obj[0] = args;
19082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19083 if (!SWIG_IsOK(res1)) {
19084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19085 }
19086 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19087 {
19088 PyThreadState* __tstate = wxPyBeginAllowThreads();
19089 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19090 wxPyEndAllowThreads(__tstate);
19091 if (PyErr_Occurred()) SWIG_fail;
19092 }
19093 resultobj = SWIG_From_long(static_cast< long >(result));
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19101 PyObject *resultobj = 0;
19102 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19103 int arg2 ;
19104 void *argp1 = 0 ;
19105 int res1 = 0 ;
19106 int val2 ;
19107 int ecode2 = 0 ;
19108 PyObject * obj0 = 0 ;
19109 PyObject * obj1 = 0 ;
19110 char * kwnames[] = {
19111 (char *) "self",(char *) "i", NULL
19112 };
19113
19114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19116 if (!SWIG_IsOK(res1)) {
19117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19118 }
19119 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19120 ecode2 = SWIG_AsVal_int(obj1, &val2);
19121 if (!SWIG_IsOK(ecode2)) {
19122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19123 }
19124 arg2 = static_cast< int >(val2);
19125 {
19126 PyThreadState* __tstate = wxPyBeginAllowThreads();
19127 (arg1)->SetInt(arg2);
19128 wxPyEndAllowThreads(__tstate);
19129 if (PyErr_Occurred()) SWIG_fail;
19130 }
19131 resultobj = SWIG_Py_Void();
19132 return resultobj;
19133 fail:
19134 return NULL;
19135 }
19136
19137
19138 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19139 PyObject *resultobj = 0;
19140 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19141 int result;
19142 void *argp1 = 0 ;
19143 int res1 = 0 ;
19144 PyObject *swig_obj[1] ;
19145
19146 if (!args) SWIG_fail;
19147 swig_obj[0] = args;
19148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19149 if (!SWIG_IsOK(res1)) {
19150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19151 }
19152 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 resultobj = SWIG_From_int(static_cast< int >(result));
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19167 PyObject *resultobj = 0;
19168 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19169 PyObject *result = 0 ;
19170 void *argp1 = 0 ;
19171 int res1 = 0 ;
19172 PyObject *swig_obj[1] ;
19173
19174 if (!args) SWIG_fail;
19175 swig_obj[0] = args;
19176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19177 if (!SWIG_IsOK(res1)) {
19178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19179 }
19180 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19181 {
19182 PyThreadState* __tstate = wxPyBeginAllowThreads();
19183 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19184 wxPyEndAllowThreads(__tstate);
19185 if (PyErr_Occurred()) SWIG_fail;
19186 }
19187 resultobj = result;
19188 return resultobj;
19189 fail:
19190 return NULL;
19191 }
19192
19193
19194 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19195 PyObject *resultobj = 0;
19196 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19197 PyObject *arg2 = (PyObject *) 0 ;
19198 void *argp1 = 0 ;
19199 int res1 = 0 ;
19200 PyObject * obj0 = 0 ;
19201 PyObject * obj1 = 0 ;
19202 char * kwnames[] = {
19203 (char *) "self",(char *) "clientData", NULL
19204 };
19205
19206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19208 if (!SWIG_IsOK(res1)) {
19209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19210 }
19211 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19212 arg2 = obj1;
19213 {
19214 PyThreadState* __tstate = wxPyBeginAllowThreads();
19215 wxCommandEvent_SetClientData(arg1,arg2);
19216 wxPyEndAllowThreads(__tstate);
19217 if (PyErr_Occurred()) SWIG_fail;
19218 }
19219 resultobj = SWIG_Py_Void();
19220 return resultobj;
19221 fail:
19222 return NULL;
19223 }
19224
19225
19226 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19227 PyObject *resultobj = 0;
19228 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19229 wxEvent *result = 0 ;
19230 void *argp1 = 0 ;
19231 int res1 = 0 ;
19232 PyObject *swig_obj[1] ;
19233
19234 if (!args) SWIG_fail;
19235 swig_obj[0] = args;
19236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19237 if (!SWIG_IsOK(res1)) {
19238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19239 }
19240 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19244 wxPyEndAllowThreads(__tstate);
19245 if (PyErr_Occurred()) SWIG_fail;
19246 }
19247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19248 return resultobj;
19249 fail:
19250 return NULL;
19251 }
19252
19253
19254 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19255 PyObject *obj;
19256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19257 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19258 return SWIG_Py_Void();
19259 }
19260
19261 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19262 return SWIG_Python_InitShadowInstance(args);
19263 }
19264
19265 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19266 PyObject *resultobj = 0;
19267 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19268 int arg2 = (int) 0 ;
19269 wxNotifyEvent *result = 0 ;
19270 int val1 ;
19271 int ecode1 = 0 ;
19272 int val2 ;
19273 int ecode2 = 0 ;
19274 PyObject * obj0 = 0 ;
19275 PyObject * obj1 = 0 ;
19276 char * kwnames[] = {
19277 (char *) "commandType",(char *) "winid", NULL
19278 };
19279
19280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19281 if (obj0) {
19282 ecode1 = SWIG_AsVal_int(obj0, &val1);
19283 if (!SWIG_IsOK(ecode1)) {
19284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19285 }
19286 arg1 = static_cast< wxEventType >(val1);
19287 }
19288 if (obj1) {
19289 ecode2 = SWIG_AsVal_int(obj1, &val2);
19290 if (!SWIG_IsOK(ecode2)) {
19291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19292 }
19293 arg2 = static_cast< int >(val2);
19294 }
19295 {
19296 PyThreadState* __tstate = wxPyBeginAllowThreads();
19297 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19302 return resultobj;
19303 fail:
19304 return NULL;
19305 }
19306
19307
19308 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19309 PyObject *resultobj = 0;
19310 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19311 void *argp1 = 0 ;
19312 int res1 = 0 ;
19313 PyObject *swig_obj[1] ;
19314
19315 if (!args) SWIG_fail;
19316 swig_obj[0] = args;
19317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19318 if (!SWIG_IsOK(res1)) {
19319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19320 }
19321 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19322 {
19323 PyThreadState* __tstate = wxPyBeginAllowThreads();
19324 (arg1)->Veto();
19325 wxPyEndAllowThreads(__tstate);
19326 if (PyErr_Occurred()) SWIG_fail;
19327 }
19328 resultobj = SWIG_Py_Void();
19329 return resultobj;
19330 fail:
19331 return NULL;
19332 }
19333
19334
19335 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19336 PyObject *resultobj = 0;
19337 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19338 void *argp1 = 0 ;
19339 int res1 = 0 ;
19340 PyObject *swig_obj[1] ;
19341
19342 if (!args) SWIG_fail;
19343 swig_obj[0] = args;
19344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19345 if (!SWIG_IsOK(res1)) {
19346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19347 }
19348 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19349 {
19350 PyThreadState* __tstate = wxPyBeginAllowThreads();
19351 (arg1)->Allow();
19352 wxPyEndAllowThreads(__tstate);
19353 if (PyErr_Occurred()) SWIG_fail;
19354 }
19355 resultobj = SWIG_Py_Void();
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19363 PyObject *resultobj = 0;
19364 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19365 bool result;
19366 void *argp1 = 0 ;
19367 int res1 = 0 ;
19368 PyObject *swig_obj[1] ;
19369
19370 if (!args) SWIG_fail;
19371 swig_obj[0] = args;
19372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19373 if (!SWIG_IsOK(res1)) {
19374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19375 }
19376 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (bool)(arg1)->IsAllowed();
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 {
19384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19385 }
19386 return resultobj;
19387 fail:
19388 return NULL;
19389 }
19390
19391
19392 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19393 PyObject *obj;
19394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19395 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19396 return SWIG_Py_Void();
19397 }
19398
19399 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19400 return SWIG_Python_InitShadowInstance(args);
19401 }
19402
19403 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj = 0;
19405 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19406 int arg2 = (int) 0 ;
19407 int arg3 = (int) 0 ;
19408 int arg4 = (int) 0 ;
19409 wxScrollEvent *result = 0 ;
19410 int val1 ;
19411 int ecode1 = 0 ;
19412 int val2 ;
19413 int ecode2 = 0 ;
19414 int val3 ;
19415 int ecode3 = 0 ;
19416 int val4 ;
19417 int ecode4 = 0 ;
19418 PyObject * obj0 = 0 ;
19419 PyObject * obj1 = 0 ;
19420 PyObject * obj2 = 0 ;
19421 PyObject * obj3 = 0 ;
19422 char * kwnames[] = {
19423 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19424 };
19425
19426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19427 if (obj0) {
19428 ecode1 = SWIG_AsVal_int(obj0, &val1);
19429 if (!SWIG_IsOK(ecode1)) {
19430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19431 }
19432 arg1 = static_cast< wxEventType >(val1);
19433 }
19434 if (obj1) {
19435 ecode2 = SWIG_AsVal_int(obj1, &val2);
19436 if (!SWIG_IsOK(ecode2)) {
19437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19438 }
19439 arg2 = static_cast< int >(val2);
19440 }
19441 if (obj2) {
19442 ecode3 = SWIG_AsVal_int(obj2, &val3);
19443 if (!SWIG_IsOK(ecode3)) {
19444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19445 }
19446 arg3 = static_cast< int >(val3);
19447 }
19448 if (obj3) {
19449 ecode4 = SWIG_AsVal_int(obj3, &val4);
19450 if (!SWIG_IsOK(ecode4)) {
19451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19452 }
19453 arg4 = static_cast< int >(val4);
19454 }
19455 {
19456 PyThreadState* __tstate = wxPyBeginAllowThreads();
19457 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19458 wxPyEndAllowThreads(__tstate);
19459 if (PyErr_Occurred()) SWIG_fail;
19460 }
19461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19462 return resultobj;
19463 fail:
19464 return NULL;
19465 }
19466
19467
19468 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19469 PyObject *resultobj = 0;
19470 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19471 int result;
19472 void *argp1 = 0 ;
19473 int res1 = 0 ;
19474 PyObject *swig_obj[1] ;
19475
19476 if (!args) SWIG_fail;
19477 swig_obj[0] = args;
19478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19479 if (!SWIG_IsOK(res1)) {
19480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19481 }
19482 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19486 wxPyEndAllowThreads(__tstate);
19487 if (PyErr_Occurred()) SWIG_fail;
19488 }
19489 resultobj = SWIG_From_int(static_cast< int >(result));
19490 return resultobj;
19491 fail:
19492 return NULL;
19493 }
19494
19495
19496 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19497 PyObject *resultobj = 0;
19498 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19499 int result;
19500 void *argp1 = 0 ;
19501 int res1 = 0 ;
19502 PyObject *swig_obj[1] ;
19503
19504 if (!args) SWIG_fail;
19505 swig_obj[0] = args;
19506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19507 if (!SWIG_IsOK(res1)) {
19508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19509 }
19510 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19511 {
19512 PyThreadState* __tstate = wxPyBeginAllowThreads();
19513 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19514 wxPyEndAllowThreads(__tstate);
19515 if (PyErr_Occurred()) SWIG_fail;
19516 }
19517 resultobj = SWIG_From_int(static_cast< int >(result));
19518 return resultobj;
19519 fail:
19520 return NULL;
19521 }
19522
19523
19524 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19525 PyObject *resultobj = 0;
19526 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19527 int arg2 ;
19528 void *argp1 = 0 ;
19529 int res1 = 0 ;
19530 int val2 ;
19531 int ecode2 = 0 ;
19532 PyObject * obj0 = 0 ;
19533 PyObject * obj1 = 0 ;
19534 char * kwnames[] = {
19535 (char *) "self",(char *) "orient", NULL
19536 };
19537
19538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19540 if (!SWIG_IsOK(res1)) {
19541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19542 }
19543 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19544 ecode2 = SWIG_AsVal_int(obj1, &val2);
19545 if (!SWIG_IsOK(ecode2)) {
19546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19547 }
19548 arg2 = static_cast< int >(val2);
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 (arg1)->SetOrientation(arg2);
19552 wxPyEndAllowThreads(__tstate);
19553 if (PyErr_Occurred()) SWIG_fail;
19554 }
19555 resultobj = SWIG_Py_Void();
19556 return resultobj;
19557 fail:
19558 return NULL;
19559 }
19560
19561
19562 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj = 0;
19564 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19565 int arg2 ;
19566 void *argp1 = 0 ;
19567 int res1 = 0 ;
19568 int val2 ;
19569 int ecode2 = 0 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 char * kwnames[] = {
19573 (char *) "self",(char *) "pos", NULL
19574 };
19575
19576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19578 if (!SWIG_IsOK(res1)) {
19579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19580 }
19581 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19582 ecode2 = SWIG_AsVal_int(obj1, &val2);
19583 if (!SWIG_IsOK(ecode2)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19585 }
19586 arg2 = static_cast< int >(val2);
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 (arg1)->SetPosition(arg2);
19590 wxPyEndAllowThreads(__tstate);
19591 if (PyErr_Occurred()) SWIG_fail;
19592 }
19593 resultobj = SWIG_Py_Void();
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19601 PyObject *obj;
19602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19603 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19604 return SWIG_Py_Void();
19605 }
19606
19607 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19608 return SWIG_Python_InitShadowInstance(args);
19609 }
19610
19611 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19612 PyObject *resultobj = 0;
19613 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19614 int arg2 = (int) 0 ;
19615 int arg3 = (int) 0 ;
19616 wxScrollWinEvent *result = 0 ;
19617 int val1 ;
19618 int ecode1 = 0 ;
19619 int val2 ;
19620 int ecode2 = 0 ;
19621 int val3 ;
19622 int ecode3 = 0 ;
19623 PyObject * obj0 = 0 ;
19624 PyObject * obj1 = 0 ;
19625 PyObject * obj2 = 0 ;
19626 char * kwnames[] = {
19627 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19628 };
19629
19630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19631 if (obj0) {
19632 ecode1 = SWIG_AsVal_int(obj0, &val1);
19633 if (!SWIG_IsOK(ecode1)) {
19634 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19635 }
19636 arg1 = static_cast< wxEventType >(val1);
19637 }
19638 if (obj1) {
19639 ecode2 = SWIG_AsVal_int(obj1, &val2);
19640 if (!SWIG_IsOK(ecode2)) {
19641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19642 }
19643 arg2 = static_cast< int >(val2);
19644 }
19645 if (obj2) {
19646 ecode3 = SWIG_AsVal_int(obj2, &val3);
19647 if (!SWIG_IsOK(ecode3)) {
19648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19649 }
19650 arg3 = static_cast< int >(val3);
19651 }
19652 {
19653 PyThreadState* __tstate = wxPyBeginAllowThreads();
19654 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19666 PyObject *resultobj = 0;
19667 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19668 int result;
19669 void *argp1 = 0 ;
19670 int res1 = 0 ;
19671 PyObject *swig_obj[1] ;
19672
19673 if (!args) SWIG_fail;
19674 swig_obj[0] = args;
19675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19676 if (!SWIG_IsOK(res1)) {
19677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19678 }
19679 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19680 {
19681 PyThreadState* __tstate = wxPyBeginAllowThreads();
19682 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19683 wxPyEndAllowThreads(__tstate);
19684 if (PyErr_Occurred()) SWIG_fail;
19685 }
19686 resultobj = SWIG_From_int(static_cast< int >(result));
19687 return resultobj;
19688 fail:
19689 return NULL;
19690 }
19691
19692
19693 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19694 PyObject *resultobj = 0;
19695 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19696 int result;
19697 void *argp1 = 0 ;
19698 int res1 = 0 ;
19699 PyObject *swig_obj[1] ;
19700
19701 if (!args) SWIG_fail;
19702 swig_obj[0] = args;
19703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19704 if (!SWIG_IsOK(res1)) {
19705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19706 }
19707 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19708 {
19709 PyThreadState* __tstate = wxPyBeginAllowThreads();
19710 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19711 wxPyEndAllowThreads(__tstate);
19712 if (PyErr_Occurred()) SWIG_fail;
19713 }
19714 resultobj = SWIG_From_int(static_cast< int >(result));
19715 return resultobj;
19716 fail:
19717 return NULL;
19718 }
19719
19720
19721 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19722 PyObject *resultobj = 0;
19723 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19724 int arg2 ;
19725 void *argp1 = 0 ;
19726 int res1 = 0 ;
19727 int val2 ;
19728 int ecode2 = 0 ;
19729 PyObject * obj0 = 0 ;
19730 PyObject * obj1 = 0 ;
19731 char * kwnames[] = {
19732 (char *) "self",(char *) "orient", NULL
19733 };
19734
19735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19737 if (!SWIG_IsOK(res1)) {
19738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19739 }
19740 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19741 ecode2 = SWIG_AsVal_int(obj1, &val2);
19742 if (!SWIG_IsOK(ecode2)) {
19743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19744 }
19745 arg2 = static_cast< int >(val2);
19746 {
19747 PyThreadState* __tstate = wxPyBeginAllowThreads();
19748 (arg1)->SetOrientation(arg2);
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 resultobj = SWIG_Py_Void();
19753 return resultobj;
19754 fail:
19755 return NULL;
19756 }
19757
19758
19759 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19760 PyObject *resultobj = 0;
19761 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19762 int arg2 ;
19763 void *argp1 = 0 ;
19764 int res1 = 0 ;
19765 int val2 ;
19766 int ecode2 = 0 ;
19767 PyObject * obj0 = 0 ;
19768 PyObject * obj1 = 0 ;
19769 char * kwnames[] = {
19770 (char *) "self",(char *) "pos", NULL
19771 };
19772
19773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19775 if (!SWIG_IsOK(res1)) {
19776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19777 }
19778 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19779 ecode2 = SWIG_AsVal_int(obj1, &val2);
19780 if (!SWIG_IsOK(ecode2)) {
19781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19782 }
19783 arg2 = static_cast< int >(val2);
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 (arg1)->SetPosition(arg2);
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 resultobj = SWIG_Py_Void();
19791 return resultobj;
19792 fail:
19793 return NULL;
19794 }
19795
19796
19797 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19798 PyObject *obj;
19799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19800 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19801 return SWIG_Py_Void();
19802 }
19803
19804 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19805 return SWIG_Python_InitShadowInstance(args);
19806 }
19807
19808 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19809 PyObject *resultobj = 0;
19810 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19811 wxMouseEvent *result = 0 ;
19812 int val1 ;
19813 int ecode1 = 0 ;
19814 PyObject * obj0 = 0 ;
19815 char * kwnames[] = {
19816 (char *) "mouseType", NULL
19817 };
19818
19819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19820 if (obj0) {
19821 ecode1 = SWIG_AsVal_int(obj0, &val1);
19822 if (!SWIG_IsOK(ecode1)) {
19823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19824 }
19825 arg1 = static_cast< wxEventType >(val1);
19826 }
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19835 }
19836 return resultobj;
19837 fail:
19838 return NULL;
19839 }
19840
19841
19842 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19843 PyObject *resultobj = 0;
19844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19845 bool result;
19846 void *argp1 = 0 ;
19847 int res1 = 0 ;
19848 PyObject *swig_obj[1] ;
19849
19850 if (!args) SWIG_fail;
19851 swig_obj[0] = args;
19852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19853 if (!SWIG_IsOK(res1)) {
19854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19855 }
19856 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19857 {
19858 PyThreadState* __tstate = wxPyBeginAllowThreads();
19859 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19860 wxPyEndAllowThreads(__tstate);
19861 if (PyErr_Occurred()) SWIG_fail;
19862 }
19863 {
19864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19865 }
19866 return resultobj;
19867 fail:
19868 return NULL;
19869 }
19870
19871
19872 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj = 0;
19874 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19875 int arg2 = (int) wxMOUSE_BTN_ANY ;
19876 bool result;
19877 void *argp1 = 0 ;
19878 int res1 = 0 ;
19879 int val2 ;
19880 int ecode2 = 0 ;
19881 PyObject * obj0 = 0 ;
19882 PyObject * obj1 = 0 ;
19883 char * kwnames[] = {
19884 (char *) "self",(char *) "but", NULL
19885 };
19886
19887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19889 if (!SWIG_IsOK(res1)) {
19890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19891 }
19892 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19893 if (obj1) {
19894 ecode2 = SWIG_AsVal_int(obj1, &val2);
19895 if (!SWIG_IsOK(ecode2)) {
19896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19897 }
19898 arg2 = static_cast< int >(val2);
19899 }
19900 {
19901 PyThreadState* __tstate = wxPyBeginAllowThreads();
19902 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19903 wxPyEndAllowThreads(__tstate);
19904 if (PyErr_Occurred()) SWIG_fail;
19905 }
19906 {
19907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19908 }
19909 return resultobj;
19910 fail:
19911 return NULL;
19912 }
19913
19914
19915 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19916 PyObject *resultobj = 0;
19917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19918 int arg2 = (int) wxMOUSE_BTN_ANY ;
19919 bool result;
19920 void *argp1 = 0 ;
19921 int res1 = 0 ;
19922 int val2 ;
19923 int ecode2 = 0 ;
19924 PyObject * obj0 = 0 ;
19925 PyObject * obj1 = 0 ;
19926 char * kwnames[] = {
19927 (char *) "self",(char *) "but", NULL
19928 };
19929
19930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19932 if (!SWIG_IsOK(res1)) {
19933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19934 }
19935 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19936 if (obj1) {
19937 ecode2 = SWIG_AsVal_int(obj1, &val2);
19938 if (!SWIG_IsOK(ecode2)) {
19939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19940 }
19941 arg2 = static_cast< int >(val2);
19942 }
19943 {
19944 PyThreadState* __tstate = wxPyBeginAllowThreads();
19945 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19946 wxPyEndAllowThreads(__tstate);
19947 if (PyErr_Occurred()) SWIG_fail;
19948 }
19949 {
19950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19951 }
19952 return resultobj;
19953 fail:
19954 return NULL;
19955 }
19956
19957
19958 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19959 PyObject *resultobj = 0;
19960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19961 int arg2 = (int) wxMOUSE_BTN_ANY ;
19962 bool result;
19963 void *argp1 = 0 ;
19964 int res1 = 0 ;
19965 int val2 ;
19966 int ecode2 = 0 ;
19967 PyObject * obj0 = 0 ;
19968 PyObject * obj1 = 0 ;
19969 char * kwnames[] = {
19970 (char *) "self",(char *) "but", NULL
19971 };
19972
19973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19975 if (!SWIG_IsOK(res1)) {
19976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19977 }
19978 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19979 if (obj1) {
19980 ecode2 = SWIG_AsVal_int(obj1, &val2);
19981 if (!SWIG_IsOK(ecode2)) {
19982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19983 }
19984 arg2 = static_cast< int >(val2);
19985 }
19986 {
19987 PyThreadState* __tstate = wxPyBeginAllowThreads();
19988 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19989 wxPyEndAllowThreads(__tstate);
19990 if (PyErr_Occurred()) SWIG_fail;
19991 }
19992 {
19993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19994 }
19995 return resultobj;
19996 fail:
19997 return NULL;
19998 }
19999
20000
20001 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj = 0;
20003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20004 int arg2 ;
20005 bool result;
20006 void *argp1 = 0 ;
20007 int res1 = 0 ;
20008 int val2 ;
20009 int ecode2 = 0 ;
20010 PyObject * obj0 = 0 ;
20011 PyObject * obj1 = 0 ;
20012 char * kwnames[] = {
20013 (char *) "self",(char *) "button", NULL
20014 };
20015
20016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20018 if (!SWIG_IsOK(res1)) {
20019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20020 }
20021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20022 ecode2 = SWIG_AsVal_int(obj1, &val2);
20023 if (!SWIG_IsOK(ecode2)) {
20024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20025 }
20026 arg2 = static_cast< int >(val2);
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 {
20034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20035 }
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20043 PyObject *resultobj = 0;
20044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20045 int arg2 ;
20046 bool result;
20047 void *argp1 = 0 ;
20048 int res1 = 0 ;
20049 int val2 ;
20050 int ecode2 = 0 ;
20051 PyObject * obj0 = 0 ;
20052 PyObject * obj1 = 0 ;
20053 char * kwnames[] = {
20054 (char *) "self",(char *) "but", NULL
20055 };
20056
20057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20059 if (!SWIG_IsOK(res1)) {
20060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20061 }
20062 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20063 ecode2 = SWIG_AsVal_int(obj1, &val2);
20064 if (!SWIG_IsOK(ecode2)) {
20065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20066 }
20067 arg2 = static_cast< int >(val2);
20068 {
20069 PyThreadState* __tstate = wxPyBeginAllowThreads();
20070 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20071 wxPyEndAllowThreads(__tstate);
20072 if (PyErr_Occurred()) SWIG_fail;
20073 }
20074 {
20075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20076 }
20077 return resultobj;
20078 fail:
20079 return NULL;
20080 }
20081
20082
20083 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20084 PyObject *resultobj = 0;
20085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20086 int result;
20087 void *argp1 = 0 ;
20088 int res1 = 0 ;
20089 PyObject *swig_obj[1] ;
20090
20091 if (!args) SWIG_fail;
20092 swig_obj[0] = args;
20093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20094 if (!SWIG_IsOK(res1)) {
20095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20096 }
20097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20098 {
20099 PyThreadState* __tstate = wxPyBeginAllowThreads();
20100 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20101 wxPyEndAllowThreads(__tstate);
20102 if (PyErr_Occurred()) SWIG_fail;
20103 }
20104 resultobj = SWIG_From_int(static_cast< int >(result));
20105 return resultobj;
20106 fail:
20107 return NULL;
20108 }
20109
20110
20111 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20112 PyObject *resultobj = 0;
20113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20114 bool result;
20115 void *argp1 = 0 ;
20116 int res1 = 0 ;
20117 PyObject *swig_obj[1] ;
20118
20119 if (!args) SWIG_fail;
20120 swig_obj[0] = args;
20121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20122 if (!SWIG_IsOK(res1)) {
20123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20124 }
20125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20126 {
20127 PyThreadState* __tstate = wxPyBeginAllowThreads();
20128 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20129 wxPyEndAllowThreads(__tstate);
20130 if (PyErr_Occurred()) SWIG_fail;
20131 }
20132 {
20133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20134 }
20135 return resultobj;
20136 fail:
20137 return NULL;
20138 }
20139
20140
20141 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20142 PyObject *resultobj = 0;
20143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20144 bool result;
20145 void *argp1 = 0 ;
20146 int res1 = 0 ;
20147 PyObject *swig_obj[1] ;
20148
20149 if (!args) SWIG_fail;
20150 swig_obj[0] = args;
20151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20152 if (!SWIG_IsOK(res1)) {
20153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20154 }
20155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20156 {
20157 PyThreadState* __tstate = wxPyBeginAllowThreads();
20158 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20159 wxPyEndAllowThreads(__tstate);
20160 if (PyErr_Occurred()) SWIG_fail;
20161 }
20162 {
20163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20164 }
20165 return resultobj;
20166 fail:
20167 return NULL;
20168 }
20169
20170
20171 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20172 PyObject *resultobj = 0;
20173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20174 bool result;
20175 void *argp1 = 0 ;
20176 int res1 = 0 ;
20177 PyObject *swig_obj[1] ;
20178
20179 if (!args) SWIG_fail;
20180 swig_obj[0] = args;
20181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20182 if (!SWIG_IsOK(res1)) {
20183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20184 }
20185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20186 {
20187 PyThreadState* __tstate = wxPyBeginAllowThreads();
20188 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20189 wxPyEndAllowThreads(__tstate);
20190 if (PyErr_Occurred()) SWIG_fail;
20191 }
20192 {
20193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20194 }
20195 return resultobj;
20196 fail:
20197 return NULL;
20198 }
20199
20200
20201 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20202 PyObject *resultobj = 0;
20203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20204 bool result;
20205 void *argp1 = 0 ;
20206 int res1 = 0 ;
20207 PyObject *swig_obj[1] ;
20208
20209 if (!args) SWIG_fail;
20210 swig_obj[0] = args;
20211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20212 if (!SWIG_IsOK(res1)) {
20213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20214 }
20215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20219 wxPyEndAllowThreads(__tstate);
20220 if (PyErr_Occurred()) SWIG_fail;
20221 }
20222 {
20223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20224 }
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20232 PyObject *resultobj = 0;
20233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20234 bool result;
20235 void *argp1 = 0 ;
20236 int res1 = 0 ;
20237 PyObject *swig_obj[1] ;
20238
20239 if (!args) SWIG_fail;
20240 swig_obj[0] = args;
20241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20242 if (!SWIG_IsOK(res1)) {
20243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20244 }
20245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 {
20253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20254 }
20255 return resultobj;
20256 fail:
20257 return NULL;
20258 }
20259
20260
20261 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20262 PyObject *resultobj = 0;
20263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20264 bool result;
20265 void *argp1 = 0 ;
20266 int res1 = 0 ;
20267 PyObject *swig_obj[1] ;
20268
20269 if (!args) SWIG_fail;
20270 swig_obj[0] = args;
20271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20272 if (!SWIG_IsOK(res1)) {
20273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20274 }
20275 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20276 {
20277 PyThreadState* __tstate = wxPyBeginAllowThreads();
20278 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20279 wxPyEndAllowThreads(__tstate);
20280 if (PyErr_Occurred()) SWIG_fail;
20281 }
20282 {
20283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20284 }
20285 return resultobj;
20286 fail:
20287 return NULL;
20288 }
20289
20290
20291 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20292 PyObject *resultobj = 0;
20293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20294 bool result;
20295 void *argp1 = 0 ;
20296 int res1 = 0 ;
20297 PyObject *swig_obj[1] ;
20298
20299 if (!args) SWIG_fail;
20300 swig_obj[0] = args;
20301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20302 if (!SWIG_IsOK(res1)) {
20303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20304 }
20305 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20306 {
20307 PyThreadState* __tstate = wxPyBeginAllowThreads();
20308 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20309 wxPyEndAllowThreads(__tstate);
20310 if (PyErr_Occurred()) SWIG_fail;
20311 }
20312 {
20313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20314 }
20315 return resultobj;
20316 fail:
20317 return NULL;
20318 }
20319
20320
20321 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20322 PyObject *resultobj = 0;
20323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20324 bool result;
20325 void *argp1 = 0 ;
20326 int res1 = 0 ;
20327 PyObject *swig_obj[1] ;
20328
20329 if (!args) SWIG_fail;
20330 swig_obj[0] = args;
20331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20332 if (!SWIG_IsOK(res1)) {
20333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20334 }
20335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 {
20343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20344 }
20345 return resultobj;
20346 fail:
20347 return NULL;
20348 }
20349
20350
20351 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20352 PyObject *resultobj = 0;
20353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20354 bool result;
20355 void *argp1 = 0 ;
20356 int res1 = 0 ;
20357 PyObject *swig_obj[1] ;
20358
20359 if (!args) SWIG_fail;
20360 swig_obj[0] = args;
20361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20362 if (!SWIG_IsOK(res1)) {
20363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20364 }
20365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 {
20373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20374 }
20375 return resultobj;
20376 fail:
20377 return NULL;
20378 }
20379
20380
20381 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20382 PyObject *resultobj = 0;
20383 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20384 bool result;
20385 void *argp1 = 0 ;
20386 int res1 = 0 ;
20387 PyObject *swig_obj[1] ;
20388
20389 if (!args) SWIG_fail;
20390 swig_obj[0] = args;
20391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20392 if (!SWIG_IsOK(res1)) {
20393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20394 }
20395 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20396 {
20397 PyThreadState* __tstate = wxPyBeginAllowThreads();
20398 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20399 wxPyEndAllowThreads(__tstate);
20400 if (PyErr_Occurred()) SWIG_fail;
20401 }
20402 {
20403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20404 }
20405 return resultobj;
20406 fail:
20407 return NULL;
20408 }
20409
20410
20411 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20412 PyObject *resultobj = 0;
20413 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20414 bool result;
20415 void *argp1 = 0 ;
20416 int res1 = 0 ;
20417 PyObject *swig_obj[1] ;
20418
20419 if (!args) SWIG_fail;
20420 swig_obj[0] = args;
20421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20422 if (!SWIG_IsOK(res1)) {
20423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20424 }
20425 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20426 {
20427 PyThreadState* __tstate = wxPyBeginAllowThreads();
20428 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20429 wxPyEndAllowThreads(__tstate);
20430 if (PyErr_Occurred()) SWIG_fail;
20431 }
20432 {
20433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20434 }
20435 return resultobj;
20436 fail:
20437 return NULL;
20438 }
20439
20440
20441 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20442 PyObject *resultobj = 0;
20443 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20444 bool result;
20445 void *argp1 = 0 ;
20446 int res1 = 0 ;
20447 PyObject *swig_obj[1] ;
20448
20449 if (!args) SWIG_fail;
20450 swig_obj[0] = args;
20451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20452 if (!SWIG_IsOK(res1)) {
20453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20454 }
20455 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20456 {
20457 PyThreadState* __tstate = wxPyBeginAllowThreads();
20458 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20464 }
20465 return resultobj;
20466 fail:
20467 return NULL;
20468 }
20469
20470
20471 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20472 PyObject *resultobj = 0;
20473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20474 bool result;
20475 void *argp1 = 0 ;
20476 int res1 = 0 ;
20477 PyObject *swig_obj[1] ;
20478
20479 if (!args) SWIG_fail;
20480 swig_obj[0] = args;
20481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20482 if (!SWIG_IsOK(res1)) {
20483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20484 }
20485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20489 wxPyEndAllowThreads(__tstate);
20490 if (PyErr_Occurred()) SWIG_fail;
20491 }
20492 {
20493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20494 }
20495 return resultobj;
20496 fail:
20497 return NULL;
20498 }
20499
20500
20501 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20502 PyObject *resultobj = 0;
20503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20504 bool result;
20505 void *argp1 = 0 ;
20506 int res1 = 0 ;
20507 PyObject *swig_obj[1] ;
20508
20509 if (!args) SWIG_fail;
20510 swig_obj[0] = args;
20511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20512 if (!SWIG_IsOK(res1)) {
20513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20514 }
20515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20519 wxPyEndAllowThreads(__tstate);
20520 if (PyErr_Occurred()) SWIG_fail;
20521 }
20522 {
20523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20524 }
20525 return resultobj;
20526 fail:
20527 return NULL;
20528 }
20529
20530
20531 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20532 PyObject *resultobj = 0;
20533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20534 bool result;
20535 void *argp1 = 0 ;
20536 int res1 = 0 ;
20537 PyObject *swig_obj[1] ;
20538
20539 if (!args) SWIG_fail;
20540 swig_obj[0] = args;
20541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20542 if (!SWIG_IsOK(res1)) {
20543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20544 }
20545 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20546 {
20547 PyThreadState* __tstate = wxPyBeginAllowThreads();
20548 result = (bool)(arg1)->LeftIsDown();
20549 wxPyEndAllowThreads(__tstate);
20550 if (PyErr_Occurred()) SWIG_fail;
20551 }
20552 {
20553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20554 }
20555 return resultobj;
20556 fail:
20557 return NULL;
20558 }
20559
20560
20561 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20562 PyObject *resultobj = 0;
20563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20564 bool result;
20565 void *argp1 = 0 ;
20566 int res1 = 0 ;
20567 PyObject *swig_obj[1] ;
20568
20569 if (!args) SWIG_fail;
20570 swig_obj[0] = args;
20571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20572 if (!SWIG_IsOK(res1)) {
20573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20574 }
20575 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20576 {
20577 PyThreadState* __tstate = wxPyBeginAllowThreads();
20578 result = (bool)(arg1)->MiddleIsDown();
20579 wxPyEndAllowThreads(__tstate);
20580 if (PyErr_Occurred()) SWIG_fail;
20581 }
20582 {
20583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20584 }
20585 return resultobj;
20586 fail:
20587 return NULL;
20588 }
20589
20590
20591 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20592 PyObject *resultobj = 0;
20593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20594 bool result;
20595 void *argp1 = 0 ;
20596 int res1 = 0 ;
20597 PyObject *swig_obj[1] ;
20598
20599 if (!args) SWIG_fail;
20600 swig_obj[0] = args;
20601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20602 if (!SWIG_IsOK(res1)) {
20603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20604 }
20605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20606 {
20607 PyThreadState* __tstate = wxPyBeginAllowThreads();
20608 result = (bool)(arg1)->RightIsDown();
20609 wxPyEndAllowThreads(__tstate);
20610 if (PyErr_Occurred()) SWIG_fail;
20611 }
20612 {
20613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20614 }
20615 return resultobj;
20616 fail:
20617 return NULL;
20618 }
20619
20620
20621 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20622 PyObject *resultobj = 0;
20623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20624 bool result;
20625 void *argp1 = 0 ;
20626 int res1 = 0 ;
20627 PyObject *swig_obj[1] ;
20628
20629 if (!args) SWIG_fail;
20630 swig_obj[0] = args;
20631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20632 if (!SWIG_IsOK(res1)) {
20633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20634 }
20635 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20636 {
20637 PyThreadState* __tstate = wxPyBeginAllowThreads();
20638 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20639 wxPyEndAllowThreads(__tstate);
20640 if (PyErr_Occurred()) SWIG_fail;
20641 }
20642 {
20643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20644 }
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20652 PyObject *resultobj = 0;
20653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20654 bool result;
20655 void *argp1 = 0 ;
20656 int res1 = 0 ;
20657 PyObject *swig_obj[1] ;
20658
20659 if (!args) SWIG_fail;
20660 swig_obj[0] = args;
20661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20662 if (!SWIG_IsOK(res1)) {
20663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20664 }
20665 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20666 {
20667 PyThreadState* __tstate = wxPyBeginAllowThreads();
20668 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20669 wxPyEndAllowThreads(__tstate);
20670 if (PyErr_Occurred()) SWIG_fail;
20671 }
20672 {
20673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20674 }
20675 return resultobj;
20676 fail:
20677 return NULL;
20678 }
20679
20680
20681 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20682 PyObject *resultobj = 0;
20683 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20684 bool result;
20685 void *argp1 = 0 ;
20686 int res1 = 0 ;
20687 PyObject *swig_obj[1] ;
20688
20689 if (!args) SWIG_fail;
20690 swig_obj[0] = args;
20691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20692 if (!SWIG_IsOK(res1)) {
20693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20694 }
20695 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20696 {
20697 PyThreadState* __tstate = wxPyBeginAllowThreads();
20698 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20699 wxPyEndAllowThreads(__tstate);
20700 if (PyErr_Occurred()) SWIG_fail;
20701 }
20702 {
20703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20704 }
20705 return resultobj;
20706 fail:
20707 return NULL;
20708 }
20709
20710
20711 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20712 PyObject *resultobj = 0;
20713 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20714 bool result;
20715 void *argp1 = 0 ;
20716 int res1 = 0 ;
20717 PyObject *swig_obj[1] ;
20718
20719 if (!args) SWIG_fail;
20720 swig_obj[0] = args;
20721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20722 if (!SWIG_IsOK(res1)) {
20723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20724 }
20725 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20726 {
20727 PyThreadState* __tstate = wxPyBeginAllowThreads();
20728 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 {
20733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20734 }
20735 return resultobj;
20736 fail:
20737 return NULL;
20738 }
20739
20740
20741 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20742 PyObject *resultobj = 0;
20743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20744 wxPoint result;
20745 void *argp1 = 0 ;
20746 int res1 = 0 ;
20747 PyObject *swig_obj[1] ;
20748
20749 if (!args) SWIG_fail;
20750 swig_obj[0] = args;
20751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20752 if (!SWIG_IsOK(res1)) {
20753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20754 }
20755 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20756 {
20757 PyThreadState* __tstate = wxPyBeginAllowThreads();
20758 result = (arg1)->GetPosition();
20759 wxPyEndAllowThreads(__tstate);
20760 if (PyErr_Occurred()) SWIG_fail;
20761 }
20762 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20763 return resultobj;
20764 fail:
20765 return NULL;
20766 }
20767
20768
20769 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20770 PyObject *resultobj = 0;
20771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20772 long *arg2 = (long *) 0 ;
20773 long *arg3 = (long *) 0 ;
20774 void *argp1 = 0 ;
20775 int res1 = 0 ;
20776 long temp2 ;
20777 int res2 = SWIG_TMPOBJ ;
20778 long temp3 ;
20779 int res3 = SWIG_TMPOBJ ;
20780 PyObject *swig_obj[1] ;
20781
20782 arg2 = &temp2;
20783 arg3 = &temp3;
20784 if (!args) SWIG_fail;
20785 swig_obj[0] = args;
20786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20787 if (!SWIG_IsOK(res1)) {
20788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20789 }
20790 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20791 {
20792 PyThreadState* __tstate = wxPyBeginAllowThreads();
20793 (arg1)->GetPosition(arg2,arg3);
20794 wxPyEndAllowThreads(__tstate);
20795 if (PyErr_Occurred()) SWIG_fail;
20796 }
20797 resultobj = SWIG_Py_Void();
20798 if (SWIG_IsTmpObj(res2)) {
20799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20800 } else {
20801 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20803 }
20804 if (SWIG_IsTmpObj(res3)) {
20805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20806 } else {
20807 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20809 }
20810 return resultobj;
20811 fail:
20812 return NULL;
20813 }
20814
20815
20816 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20817 PyObject *resultobj = 0;
20818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20819 wxDC *arg2 = 0 ;
20820 wxPoint result;
20821 void *argp1 = 0 ;
20822 int res1 = 0 ;
20823 void *argp2 = 0 ;
20824 int res2 = 0 ;
20825 PyObject * obj0 = 0 ;
20826 PyObject * obj1 = 0 ;
20827 char * kwnames[] = {
20828 (char *) "self",(char *) "dc", NULL
20829 };
20830
20831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20833 if (!SWIG_IsOK(res1)) {
20834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20835 }
20836 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20837 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20838 if (!SWIG_IsOK(res2)) {
20839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20840 }
20841 if (!argp2) {
20842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20843 }
20844 arg2 = reinterpret_cast< wxDC * >(argp2);
20845 {
20846 PyThreadState* __tstate = wxPyBeginAllowThreads();
20847 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20848 wxPyEndAllowThreads(__tstate);
20849 if (PyErr_Occurred()) SWIG_fail;
20850 }
20851 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20852 return resultobj;
20853 fail:
20854 return NULL;
20855 }
20856
20857
20858 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20859 PyObject *resultobj = 0;
20860 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20861 int result;
20862 void *argp1 = 0 ;
20863 int res1 = 0 ;
20864 PyObject *swig_obj[1] ;
20865
20866 if (!args) SWIG_fail;
20867 swig_obj[0] = args;
20868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20869 if (!SWIG_IsOK(res1)) {
20870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20871 }
20872 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 result = (int)((wxMouseEvent const *)arg1)->GetX();
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 resultobj = SWIG_From_int(static_cast< int >(result));
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20887 PyObject *resultobj = 0;
20888 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20889 int result;
20890 void *argp1 = 0 ;
20891 int res1 = 0 ;
20892 PyObject *swig_obj[1] ;
20893
20894 if (!args) SWIG_fail;
20895 swig_obj[0] = args;
20896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20897 if (!SWIG_IsOK(res1)) {
20898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20899 }
20900 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20901 {
20902 PyThreadState* __tstate = wxPyBeginAllowThreads();
20903 result = (int)((wxMouseEvent const *)arg1)->GetY();
20904 wxPyEndAllowThreads(__tstate);
20905 if (PyErr_Occurred()) SWIG_fail;
20906 }
20907 resultobj = SWIG_From_int(static_cast< int >(result));
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20915 PyObject *resultobj = 0;
20916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20917 int result;
20918 void *argp1 = 0 ;
20919 int res1 = 0 ;
20920 PyObject *swig_obj[1] ;
20921
20922 if (!args) SWIG_fail;
20923 swig_obj[0] = args;
20924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20927 }
20928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_From_int(static_cast< int >(result));
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *resultobj = 0;
20944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20945 int result;
20946 void *argp1 = 0 ;
20947 int res1 = 0 ;
20948 PyObject *swig_obj[1] ;
20949
20950 if (!args) SWIG_fail;
20951 swig_obj[0] = args;
20952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20953 if (!SWIG_IsOK(res1)) {
20954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20955 }
20956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20957 {
20958 PyThreadState* __tstate = wxPyBeginAllowThreads();
20959 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 resultobj = SWIG_From_int(static_cast< int >(result));
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20971 PyObject *resultobj = 0;
20972 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20973 int result;
20974 void *argp1 = 0 ;
20975 int res1 = 0 ;
20976 PyObject *swig_obj[1] ;
20977
20978 if (!args) SWIG_fail;
20979 swig_obj[0] = args;
20980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20981 if (!SWIG_IsOK(res1)) {
20982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20983 }
20984 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20985 {
20986 PyThreadState* __tstate = wxPyBeginAllowThreads();
20987 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20988 wxPyEndAllowThreads(__tstate);
20989 if (PyErr_Occurred()) SWIG_fail;
20990 }
20991 resultobj = SWIG_From_int(static_cast< int >(result));
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20999 PyObject *resultobj = 0;
21000 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21001 bool result;
21002 void *argp1 = 0 ;
21003 int res1 = 0 ;
21004 PyObject *swig_obj[1] ;
21005
21006 if (!args) SWIG_fail;
21007 swig_obj[0] = args;
21008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21009 if (!SWIG_IsOK(res1)) {
21010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21011 }
21012 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 {
21020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21021 }
21022 return resultobj;
21023 fail:
21024 return NULL;
21025 }
21026
21027
21028 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21029 PyObject *resultobj = 0;
21030 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21031 int arg2 ;
21032 void *argp1 = 0 ;
21033 int res1 = 0 ;
21034 int val2 ;
21035 int ecode2 = 0 ;
21036 PyObject *swig_obj[2] ;
21037
21038 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21040 if (!SWIG_IsOK(res1)) {
21041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21042 }
21043 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21044 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21045 if (!SWIG_IsOK(ecode2)) {
21046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21047 }
21048 arg2 = static_cast< int >(val2);
21049 if (arg1) (arg1)->m_x = arg2;
21050
21051 resultobj = SWIG_Py_Void();
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21059 PyObject *resultobj = 0;
21060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21061 int result;
21062 void *argp1 = 0 ;
21063 int res1 = 0 ;
21064 PyObject *swig_obj[1] ;
21065
21066 if (!args) SWIG_fail;
21067 swig_obj[0] = args;
21068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21069 if (!SWIG_IsOK(res1)) {
21070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21071 }
21072 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21073 result = (int) ((arg1)->m_x);
21074 resultobj = SWIG_From_int(static_cast< int >(result));
21075 return resultobj;
21076 fail:
21077 return NULL;
21078 }
21079
21080
21081 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082 PyObject *resultobj = 0;
21083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21084 int arg2 ;
21085 void *argp1 = 0 ;
21086 int res1 = 0 ;
21087 int val2 ;
21088 int ecode2 = 0 ;
21089 PyObject *swig_obj[2] ;
21090
21091 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21093 if (!SWIG_IsOK(res1)) {
21094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21095 }
21096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21097 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21098 if (!SWIG_IsOK(ecode2)) {
21099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21100 }
21101 arg2 = static_cast< int >(val2);
21102 if (arg1) (arg1)->m_y = arg2;
21103
21104 resultobj = SWIG_Py_Void();
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21112 PyObject *resultobj = 0;
21113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21114 int result;
21115 void *argp1 = 0 ;
21116 int res1 = 0 ;
21117 PyObject *swig_obj[1] ;
21118
21119 if (!args) SWIG_fail;
21120 swig_obj[0] = args;
21121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21122 if (!SWIG_IsOK(res1)) {
21123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21124 }
21125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21126 result = (int) ((arg1)->m_y);
21127 resultobj = SWIG_From_int(static_cast< int >(result));
21128 return resultobj;
21129 fail:
21130 return NULL;
21131 }
21132
21133
21134 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21135 PyObject *resultobj = 0;
21136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21137 bool arg2 ;
21138 void *argp1 = 0 ;
21139 int res1 = 0 ;
21140 bool val2 ;
21141 int ecode2 = 0 ;
21142 PyObject *swig_obj[2] ;
21143
21144 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21146 if (!SWIG_IsOK(res1)) {
21147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21148 }
21149 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21150 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21151 if (!SWIG_IsOK(ecode2)) {
21152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21153 }
21154 arg2 = static_cast< bool >(val2);
21155 if (arg1) (arg1)->m_leftDown = arg2;
21156
21157 resultobj = SWIG_Py_Void();
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21165 PyObject *resultobj = 0;
21166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21167 bool result;
21168 void *argp1 = 0 ;
21169 int res1 = 0 ;
21170 PyObject *swig_obj[1] ;
21171
21172 if (!args) SWIG_fail;
21173 swig_obj[0] = args;
21174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21175 if (!SWIG_IsOK(res1)) {
21176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21177 }
21178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21179 result = (bool) ((arg1)->m_leftDown);
21180 {
21181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21182 }
21183 return resultobj;
21184 fail:
21185 return NULL;
21186 }
21187
21188
21189 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21190 PyObject *resultobj = 0;
21191 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21192 bool arg2 ;
21193 void *argp1 = 0 ;
21194 int res1 = 0 ;
21195 bool val2 ;
21196 int ecode2 = 0 ;
21197 PyObject *swig_obj[2] ;
21198
21199 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21201 if (!SWIG_IsOK(res1)) {
21202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21203 }
21204 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21205 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21206 if (!SWIG_IsOK(ecode2)) {
21207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21208 }
21209 arg2 = static_cast< bool >(val2);
21210 if (arg1) (arg1)->m_middleDown = arg2;
21211
21212 resultobj = SWIG_Py_Void();
21213 return resultobj;
21214 fail:
21215 return NULL;
21216 }
21217
21218
21219 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21220 PyObject *resultobj = 0;
21221 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21222 bool result;
21223 void *argp1 = 0 ;
21224 int res1 = 0 ;
21225 PyObject *swig_obj[1] ;
21226
21227 if (!args) SWIG_fail;
21228 swig_obj[0] = args;
21229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21230 if (!SWIG_IsOK(res1)) {
21231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21232 }
21233 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21234 result = (bool) ((arg1)->m_middleDown);
21235 {
21236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21237 }
21238 return resultobj;
21239 fail:
21240 return NULL;
21241 }
21242
21243
21244 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21245 PyObject *resultobj = 0;
21246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21247 bool arg2 ;
21248 void *argp1 = 0 ;
21249 int res1 = 0 ;
21250 bool val2 ;
21251 int ecode2 = 0 ;
21252 PyObject *swig_obj[2] ;
21253
21254 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21256 if (!SWIG_IsOK(res1)) {
21257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21258 }
21259 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21260 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21261 if (!SWIG_IsOK(ecode2)) {
21262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21263 }
21264 arg2 = static_cast< bool >(val2);
21265 if (arg1) (arg1)->m_rightDown = arg2;
21266
21267 resultobj = SWIG_Py_Void();
21268 return resultobj;
21269 fail:
21270 return NULL;
21271 }
21272
21273
21274 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21275 PyObject *resultobj = 0;
21276 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21277 bool result;
21278 void *argp1 = 0 ;
21279 int res1 = 0 ;
21280 PyObject *swig_obj[1] ;
21281
21282 if (!args) SWIG_fail;
21283 swig_obj[0] = args;
21284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21285 if (!SWIG_IsOK(res1)) {
21286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21287 }
21288 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21289 result = (bool) ((arg1)->m_rightDown);
21290 {
21291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21292 }
21293 return resultobj;
21294 fail:
21295 return NULL;
21296 }
21297
21298
21299 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21300 PyObject *resultobj = 0;
21301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21302 bool arg2 ;
21303 void *argp1 = 0 ;
21304 int res1 = 0 ;
21305 bool val2 ;
21306 int ecode2 = 0 ;
21307 PyObject *swig_obj[2] ;
21308
21309 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21311 if (!SWIG_IsOK(res1)) {
21312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21313 }
21314 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21315 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21316 if (!SWIG_IsOK(ecode2)) {
21317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21318 }
21319 arg2 = static_cast< bool >(val2);
21320 if (arg1) (arg1)->m_controlDown = arg2;
21321
21322 resultobj = SWIG_Py_Void();
21323 return resultobj;
21324 fail:
21325 return NULL;
21326 }
21327
21328
21329 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21330 PyObject *resultobj = 0;
21331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21332 bool result;
21333 void *argp1 = 0 ;
21334 int res1 = 0 ;
21335 PyObject *swig_obj[1] ;
21336
21337 if (!args) SWIG_fail;
21338 swig_obj[0] = args;
21339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21340 if (!SWIG_IsOK(res1)) {
21341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21342 }
21343 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21344 result = (bool) ((arg1)->m_controlDown);
21345 {
21346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21347 }
21348 return resultobj;
21349 fail:
21350 return NULL;
21351 }
21352
21353
21354 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21355 PyObject *resultobj = 0;
21356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21357 bool arg2 ;
21358 void *argp1 = 0 ;
21359 int res1 = 0 ;
21360 bool val2 ;
21361 int ecode2 = 0 ;
21362 PyObject *swig_obj[2] ;
21363
21364 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21366 if (!SWIG_IsOK(res1)) {
21367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21368 }
21369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21370 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21371 if (!SWIG_IsOK(ecode2)) {
21372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21373 }
21374 arg2 = static_cast< bool >(val2);
21375 if (arg1) (arg1)->m_shiftDown = arg2;
21376
21377 resultobj = SWIG_Py_Void();
21378 return resultobj;
21379 fail:
21380 return NULL;
21381 }
21382
21383
21384 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21385 PyObject *resultobj = 0;
21386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21387 bool result;
21388 void *argp1 = 0 ;
21389 int res1 = 0 ;
21390 PyObject *swig_obj[1] ;
21391
21392 if (!args) SWIG_fail;
21393 swig_obj[0] = args;
21394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21395 if (!SWIG_IsOK(res1)) {
21396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21397 }
21398 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21399 result = (bool) ((arg1)->m_shiftDown);
21400 {
21401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21402 }
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21410 PyObject *resultobj = 0;
21411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21412 bool arg2 ;
21413 void *argp1 = 0 ;
21414 int res1 = 0 ;
21415 bool val2 ;
21416 int ecode2 = 0 ;
21417 PyObject *swig_obj[2] ;
21418
21419 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21421 if (!SWIG_IsOK(res1)) {
21422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21423 }
21424 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21425 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21426 if (!SWIG_IsOK(ecode2)) {
21427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21428 }
21429 arg2 = static_cast< bool >(val2);
21430 if (arg1) (arg1)->m_altDown = arg2;
21431
21432 resultobj = SWIG_Py_Void();
21433 return resultobj;
21434 fail:
21435 return NULL;
21436 }
21437
21438
21439 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21440 PyObject *resultobj = 0;
21441 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21442 bool result;
21443 void *argp1 = 0 ;
21444 int res1 = 0 ;
21445 PyObject *swig_obj[1] ;
21446
21447 if (!args) SWIG_fail;
21448 swig_obj[0] = args;
21449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21450 if (!SWIG_IsOK(res1)) {
21451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21452 }
21453 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21454 result = (bool) ((arg1)->m_altDown);
21455 {
21456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21457 }
21458 return resultobj;
21459 fail:
21460 return NULL;
21461 }
21462
21463
21464 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21465 PyObject *resultobj = 0;
21466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21467 bool arg2 ;
21468 void *argp1 = 0 ;
21469 int res1 = 0 ;
21470 bool val2 ;
21471 int ecode2 = 0 ;
21472 PyObject *swig_obj[2] ;
21473
21474 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21476 if (!SWIG_IsOK(res1)) {
21477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21478 }
21479 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21480 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21481 if (!SWIG_IsOK(ecode2)) {
21482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21483 }
21484 arg2 = static_cast< bool >(val2);
21485 if (arg1) (arg1)->m_metaDown = arg2;
21486
21487 resultobj = SWIG_Py_Void();
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21495 PyObject *resultobj = 0;
21496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21497 bool result;
21498 void *argp1 = 0 ;
21499 int res1 = 0 ;
21500 PyObject *swig_obj[1] ;
21501
21502 if (!args) SWIG_fail;
21503 swig_obj[0] = args;
21504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21505 if (!SWIG_IsOK(res1)) {
21506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21507 }
21508 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21509 result = (bool) ((arg1)->m_metaDown);
21510 {
21511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21512 }
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21520 PyObject *resultobj = 0;
21521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21522 int arg2 ;
21523 void *argp1 = 0 ;
21524 int res1 = 0 ;
21525 int val2 ;
21526 int ecode2 = 0 ;
21527 PyObject *swig_obj[2] ;
21528
21529 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21531 if (!SWIG_IsOK(res1)) {
21532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21533 }
21534 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21535 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21536 if (!SWIG_IsOK(ecode2)) {
21537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21538 }
21539 arg2 = static_cast< int >(val2);
21540 if (arg1) (arg1)->m_wheelRotation = arg2;
21541
21542 resultobj = SWIG_Py_Void();
21543 return resultobj;
21544 fail:
21545 return NULL;
21546 }
21547
21548
21549 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21550 PyObject *resultobj = 0;
21551 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21552 int result;
21553 void *argp1 = 0 ;
21554 int res1 = 0 ;
21555 PyObject *swig_obj[1] ;
21556
21557 if (!args) SWIG_fail;
21558 swig_obj[0] = args;
21559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21560 if (!SWIG_IsOK(res1)) {
21561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21562 }
21563 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21564 result = (int) ((arg1)->m_wheelRotation);
21565 resultobj = SWIG_From_int(static_cast< int >(result));
21566 return resultobj;
21567 fail:
21568 return NULL;
21569 }
21570
21571
21572 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21573 PyObject *resultobj = 0;
21574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21575 int arg2 ;
21576 void *argp1 = 0 ;
21577 int res1 = 0 ;
21578 int val2 ;
21579 int ecode2 = 0 ;
21580 PyObject *swig_obj[2] ;
21581
21582 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21586 }
21587 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21588 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21589 if (!SWIG_IsOK(ecode2)) {
21590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21591 }
21592 arg2 = static_cast< int >(val2);
21593 if (arg1) (arg1)->m_wheelDelta = arg2;
21594
21595 resultobj = SWIG_Py_Void();
21596 return resultobj;
21597 fail:
21598 return NULL;
21599 }
21600
21601
21602 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21603 PyObject *resultobj = 0;
21604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21605 int result;
21606 void *argp1 = 0 ;
21607 int res1 = 0 ;
21608 PyObject *swig_obj[1] ;
21609
21610 if (!args) SWIG_fail;
21611 swig_obj[0] = args;
21612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21613 if (!SWIG_IsOK(res1)) {
21614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21615 }
21616 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21617 result = (int) ((arg1)->m_wheelDelta);
21618 resultobj = SWIG_From_int(static_cast< int >(result));
21619 return resultobj;
21620 fail:
21621 return NULL;
21622 }
21623
21624
21625 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21626 PyObject *resultobj = 0;
21627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21628 int arg2 ;
21629 void *argp1 = 0 ;
21630 int res1 = 0 ;
21631 int val2 ;
21632 int ecode2 = 0 ;
21633 PyObject *swig_obj[2] ;
21634
21635 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21637 if (!SWIG_IsOK(res1)) {
21638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21639 }
21640 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21641 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21642 if (!SWIG_IsOK(ecode2)) {
21643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21644 }
21645 arg2 = static_cast< int >(val2);
21646 if (arg1) (arg1)->m_linesPerAction = arg2;
21647
21648 resultobj = SWIG_Py_Void();
21649 return resultobj;
21650 fail:
21651 return NULL;
21652 }
21653
21654
21655 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21656 PyObject *resultobj = 0;
21657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21658 int result;
21659 void *argp1 = 0 ;
21660 int res1 = 0 ;
21661 PyObject *swig_obj[1] ;
21662
21663 if (!args) SWIG_fail;
21664 swig_obj[0] = args;
21665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21666 if (!SWIG_IsOK(res1)) {
21667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21668 }
21669 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21670 result = (int) ((arg1)->m_linesPerAction);
21671 resultobj = SWIG_From_int(static_cast< int >(result));
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21679 PyObject *obj;
21680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21681 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21682 return SWIG_Py_Void();
21683 }
21684
21685 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21686 return SWIG_Python_InitShadowInstance(args);
21687 }
21688
21689 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21690 PyObject *resultobj = 0;
21691 int arg1 = (int) 0 ;
21692 int arg2 = (int) 0 ;
21693 wxSetCursorEvent *result = 0 ;
21694 int val1 ;
21695 int ecode1 = 0 ;
21696 int val2 ;
21697 int ecode2 = 0 ;
21698 PyObject * obj0 = 0 ;
21699 PyObject * obj1 = 0 ;
21700 char * kwnames[] = {
21701 (char *) "x",(char *) "y", NULL
21702 };
21703
21704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21705 if (obj0) {
21706 ecode1 = SWIG_AsVal_int(obj0, &val1);
21707 if (!SWIG_IsOK(ecode1)) {
21708 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21709 }
21710 arg1 = static_cast< int >(val1);
21711 }
21712 if (obj1) {
21713 ecode2 = SWIG_AsVal_int(obj1, &val2);
21714 if (!SWIG_IsOK(ecode2)) {
21715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21716 }
21717 arg2 = static_cast< int >(val2);
21718 }
21719 {
21720 PyThreadState* __tstate = wxPyBeginAllowThreads();
21721 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21733 PyObject *resultobj = 0;
21734 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21735 int result;
21736 void *argp1 = 0 ;
21737 int res1 = 0 ;
21738 PyObject *swig_obj[1] ;
21739
21740 if (!args) SWIG_fail;
21741 swig_obj[0] = args;
21742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21743 if (!SWIG_IsOK(res1)) {
21744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21745 }
21746 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21747 {
21748 PyThreadState* __tstate = wxPyBeginAllowThreads();
21749 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21750 wxPyEndAllowThreads(__tstate);
21751 if (PyErr_Occurred()) SWIG_fail;
21752 }
21753 resultobj = SWIG_From_int(static_cast< int >(result));
21754 return resultobj;
21755 fail:
21756 return NULL;
21757 }
21758
21759
21760 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21761 PyObject *resultobj = 0;
21762 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21763 int result;
21764 void *argp1 = 0 ;
21765 int res1 = 0 ;
21766 PyObject *swig_obj[1] ;
21767
21768 if (!args) SWIG_fail;
21769 swig_obj[0] = args;
21770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21771 if (!SWIG_IsOK(res1)) {
21772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21773 }
21774 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21778 wxPyEndAllowThreads(__tstate);
21779 if (PyErr_Occurred()) SWIG_fail;
21780 }
21781 resultobj = SWIG_From_int(static_cast< int >(result));
21782 return resultobj;
21783 fail:
21784 return NULL;
21785 }
21786
21787
21788 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21789 PyObject *resultobj = 0;
21790 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21791 wxCursor *arg2 = 0 ;
21792 void *argp1 = 0 ;
21793 int res1 = 0 ;
21794 void *argp2 = 0 ;
21795 int res2 = 0 ;
21796 PyObject * obj0 = 0 ;
21797 PyObject * obj1 = 0 ;
21798 char * kwnames[] = {
21799 (char *) "self",(char *) "cursor", NULL
21800 };
21801
21802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21804 if (!SWIG_IsOK(res1)) {
21805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21806 }
21807 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21809 if (!SWIG_IsOK(res2)) {
21810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21811 }
21812 if (!argp2) {
21813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21814 }
21815 arg2 = reinterpret_cast< wxCursor * >(argp2);
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 (arg1)->SetCursor((wxCursor const &)*arg2);
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 resultobj = SWIG_Py_Void();
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21830 PyObject *resultobj = 0;
21831 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21832 wxCursor *result = 0 ;
21833 void *argp1 = 0 ;
21834 int res1 = 0 ;
21835 PyObject *swig_obj[1] ;
21836
21837 if (!args) SWIG_fail;
21838 swig_obj[0] = args;
21839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21840 if (!SWIG_IsOK(res1)) {
21841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21842 }
21843 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21844 {
21845 PyThreadState* __tstate = wxPyBeginAllowThreads();
21846 {
21847 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21848 result = (wxCursor *) &_result_ref;
21849 }
21850 wxPyEndAllowThreads(__tstate);
21851 if (PyErr_Occurred()) SWIG_fail;
21852 }
21853 {
21854 wxCursor* resultptr = new wxCursor(*result);
21855 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21856 }
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21864 PyObject *resultobj = 0;
21865 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21866 bool result;
21867 void *argp1 = 0 ;
21868 int res1 = 0 ;
21869 PyObject *swig_obj[1] ;
21870
21871 if (!args) SWIG_fail;
21872 swig_obj[0] = args;
21873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21874 if (!SWIG_IsOK(res1)) {
21875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21876 }
21877 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21878 {
21879 PyThreadState* __tstate = wxPyBeginAllowThreads();
21880 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21881 wxPyEndAllowThreads(__tstate);
21882 if (PyErr_Occurred()) SWIG_fail;
21883 }
21884 {
21885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21886 }
21887 return resultobj;
21888 fail:
21889 return NULL;
21890 }
21891
21892
21893 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21894 PyObject *obj;
21895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21896 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21897 return SWIG_Py_Void();
21898 }
21899
21900 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21901 return SWIG_Python_InitShadowInstance(args);
21902 }
21903
21904 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21905 PyObject *resultobj = 0;
21906 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21907 wxKeyEvent *result = 0 ;
21908 int val1 ;
21909 int ecode1 = 0 ;
21910 PyObject * obj0 = 0 ;
21911 char * kwnames[] = {
21912 (char *) "eventType", NULL
21913 };
21914
21915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21916 if (obj0) {
21917 ecode1 = SWIG_AsVal_int(obj0, &val1);
21918 if (!SWIG_IsOK(ecode1)) {
21919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21920 }
21921 arg1 = static_cast< wxEventType >(val1);
21922 }
21923 {
21924 PyThreadState* __tstate = wxPyBeginAllowThreads();
21925 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21926 wxPyEndAllowThreads(__tstate);
21927 if (PyErr_Occurred()) SWIG_fail;
21928 }
21929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21937 PyObject *resultobj = 0;
21938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21939 int result;
21940 void *argp1 = 0 ;
21941 int res1 = 0 ;
21942 PyObject *swig_obj[1] ;
21943
21944 if (!args) SWIG_fail;
21945 swig_obj[0] = args;
21946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21947 if (!SWIG_IsOK(res1)) {
21948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21949 }
21950 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21951 {
21952 PyThreadState* __tstate = wxPyBeginAllowThreads();
21953 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21954 wxPyEndAllowThreads(__tstate);
21955 if (PyErr_Occurred()) SWIG_fail;
21956 }
21957 resultobj = SWIG_From_int(static_cast< int >(result));
21958 return resultobj;
21959 fail:
21960 return NULL;
21961 }
21962
21963
21964 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21965 PyObject *resultobj = 0;
21966 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21967 bool result;
21968 void *argp1 = 0 ;
21969 int res1 = 0 ;
21970 PyObject *swig_obj[1] ;
21971
21972 if (!args) SWIG_fail;
21973 swig_obj[0] = args;
21974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21975 if (!SWIG_IsOK(res1)) {
21976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21977 }
21978 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 {
21986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21987 }
21988 return resultobj;
21989 fail:
21990 return NULL;
21991 }
21992
21993
21994 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21995 PyObject *resultobj = 0;
21996 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21997 bool result;
21998 void *argp1 = 0 ;
21999 int res1 = 0 ;
22000 PyObject *swig_obj[1] ;
22001
22002 if (!args) SWIG_fail;
22003 swig_obj[0] = args;
22004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22005 if (!SWIG_IsOK(res1)) {
22006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22007 }
22008 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22009 {
22010 PyThreadState* __tstate = wxPyBeginAllowThreads();
22011 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22012 wxPyEndAllowThreads(__tstate);
22013 if (PyErr_Occurred()) SWIG_fail;
22014 }
22015 {
22016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22017 }
22018 return resultobj;
22019 fail:
22020 return NULL;
22021 }
22022
22023
22024 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22025 PyObject *resultobj = 0;
22026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22027 bool result;
22028 void *argp1 = 0 ;
22029 int res1 = 0 ;
22030 PyObject *swig_obj[1] ;
22031
22032 if (!args) SWIG_fail;
22033 swig_obj[0] = args;
22034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22035 if (!SWIG_IsOK(res1)) {
22036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22037 }
22038 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22042 wxPyEndAllowThreads(__tstate);
22043 if (PyErr_Occurred()) SWIG_fail;
22044 }
22045 {
22046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22047 }
22048 return resultobj;
22049 fail:
22050 return NULL;
22051 }
22052
22053
22054 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22055 PyObject *resultobj = 0;
22056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22057 bool result;
22058 void *argp1 = 0 ;
22059 int res1 = 0 ;
22060 PyObject *swig_obj[1] ;
22061
22062 if (!args) SWIG_fail;
22063 swig_obj[0] = args;
22064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22065 if (!SWIG_IsOK(res1)) {
22066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22067 }
22068 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22069 {
22070 PyThreadState* __tstate = wxPyBeginAllowThreads();
22071 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22072 wxPyEndAllowThreads(__tstate);
22073 if (PyErr_Occurred()) SWIG_fail;
22074 }
22075 {
22076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22077 }
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22085 PyObject *resultobj = 0;
22086 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22087 bool result;
22088 void *argp1 = 0 ;
22089 int res1 = 0 ;
22090 PyObject *swig_obj[1] ;
22091
22092 if (!args) SWIG_fail;
22093 swig_obj[0] = args;
22094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22095 if (!SWIG_IsOK(res1)) {
22096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22097 }
22098 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 {
22106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22107 }
22108 return resultobj;
22109 fail:
22110 return NULL;
22111 }
22112
22113
22114 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22115 PyObject *resultobj = 0;
22116 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22117 bool result;
22118 void *argp1 = 0 ;
22119 int res1 = 0 ;
22120 PyObject *swig_obj[1] ;
22121
22122 if (!args) SWIG_fail;
22123 swig_obj[0] = args;
22124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22125 if (!SWIG_IsOK(res1)) {
22126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22127 }
22128 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22132 wxPyEndAllowThreads(__tstate);
22133 if (PyErr_Occurred()) SWIG_fail;
22134 }
22135 {
22136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22137 }
22138 return resultobj;
22139 fail:
22140 return NULL;
22141 }
22142
22143
22144 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22145 PyObject *resultobj = 0;
22146 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22147 int result;
22148 void *argp1 = 0 ;
22149 int res1 = 0 ;
22150 PyObject *swig_obj[1] ;
22151
22152 if (!args) SWIG_fail;
22153 swig_obj[0] = args;
22154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22155 if (!SWIG_IsOK(res1)) {
22156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22157 }
22158 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22159 {
22160 PyThreadState* __tstate = wxPyBeginAllowThreads();
22161 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22162 wxPyEndAllowThreads(__tstate);
22163 if (PyErr_Occurred()) SWIG_fail;
22164 }
22165 resultobj = SWIG_From_int(static_cast< int >(result));
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22173 PyObject *resultobj = 0;
22174 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22175 int result;
22176 void *argp1 = 0 ;
22177 int res1 = 0 ;
22178 PyObject *swig_obj[1] ;
22179
22180 if (!args) SWIG_fail;
22181 swig_obj[0] = args;
22182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22183 if (!SWIG_IsOK(res1)) {
22184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22185 }
22186 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22187 {
22188 PyThreadState* __tstate = wxPyBeginAllowThreads();
22189 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22190 wxPyEndAllowThreads(__tstate);
22191 if (PyErr_Occurred()) SWIG_fail;
22192 }
22193 resultobj = SWIG_From_int(static_cast< int >(result));
22194 return resultobj;
22195 fail:
22196 return NULL;
22197 }
22198
22199
22200 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22201 PyObject *resultobj = 0;
22202 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22203 int arg2 ;
22204 void *argp1 = 0 ;
22205 int res1 = 0 ;
22206 int val2 ;
22207 int ecode2 = 0 ;
22208 PyObject * obj0 = 0 ;
22209 PyObject * obj1 = 0 ;
22210 char * kwnames[] = {
22211 (char *) "self",(char *) "uniChar", NULL
22212 };
22213
22214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22216 if (!SWIG_IsOK(res1)) {
22217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22218 }
22219 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22220 ecode2 = SWIG_AsVal_int(obj1, &val2);
22221 if (!SWIG_IsOK(ecode2)) {
22222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22223 }
22224 arg2 = static_cast< int >(val2);
22225 {
22226 PyThreadState* __tstate = wxPyBeginAllowThreads();
22227 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22228 wxPyEndAllowThreads(__tstate);
22229 if (PyErr_Occurred()) SWIG_fail;
22230 }
22231 resultobj = SWIG_Py_Void();
22232 return resultobj;
22233 fail:
22234 return NULL;
22235 }
22236
22237
22238 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22239 PyObject *resultobj = 0;
22240 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22241 unsigned int result;
22242 void *argp1 = 0 ;
22243 int res1 = 0 ;
22244 PyObject *swig_obj[1] ;
22245
22246 if (!args) SWIG_fail;
22247 swig_obj[0] = args;
22248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22249 if (!SWIG_IsOK(res1)) {
22250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22251 }
22252 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22267 PyObject *resultobj = 0;
22268 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22269 unsigned int result;
22270 void *argp1 = 0 ;
22271 int res1 = 0 ;
22272 PyObject *swig_obj[1] ;
22273
22274 if (!args) SWIG_fail;
22275 swig_obj[0] = args;
22276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22277 if (!SWIG_IsOK(res1)) {
22278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22279 }
22280 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22281 {
22282 PyThreadState* __tstate = wxPyBeginAllowThreads();
22283 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22284 wxPyEndAllowThreads(__tstate);
22285 if (PyErr_Occurred()) SWIG_fail;
22286 }
22287 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22288 return resultobj;
22289 fail:
22290 return NULL;
22291 }
22292
22293
22294 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22295 PyObject *resultobj = 0;
22296 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22297 wxPoint result;
22298 void *argp1 = 0 ;
22299 int res1 = 0 ;
22300 PyObject *swig_obj[1] ;
22301
22302 if (!args) SWIG_fail;
22303 swig_obj[0] = args;
22304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22305 if (!SWIG_IsOK(res1)) {
22306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22307 }
22308 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22309 {
22310 PyThreadState* __tstate = wxPyBeginAllowThreads();
22311 result = (arg1)->GetPosition();
22312 wxPyEndAllowThreads(__tstate);
22313 if (PyErr_Occurred()) SWIG_fail;
22314 }
22315 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22316 return resultobj;
22317 fail:
22318 return NULL;
22319 }
22320
22321
22322 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22323 PyObject *resultobj = 0;
22324 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22325 long *arg2 = (long *) 0 ;
22326 long *arg3 = (long *) 0 ;
22327 void *argp1 = 0 ;
22328 int res1 = 0 ;
22329 long temp2 ;
22330 int res2 = SWIG_TMPOBJ ;
22331 long temp3 ;
22332 int res3 = SWIG_TMPOBJ ;
22333 PyObject *swig_obj[1] ;
22334
22335 arg2 = &temp2;
22336 arg3 = &temp3;
22337 if (!args) SWIG_fail;
22338 swig_obj[0] = args;
22339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22340 if (!SWIG_IsOK(res1)) {
22341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22342 }
22343 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 (arg1)->GetPosition(arg2,arg3);
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 resultobj = SWIG_Py_Void();
22351 if (SWIG_IsTmpObj(res2)) {
22352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22353 } else {
22354 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22356 }
22357 if (SWIG_IsTmpObj(res3)) {
22358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22359 } else {
22360 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22362 }
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22370 PyObject *resultobj = 0;
22371 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22372 int result;
22373 void *argp1 = 0 ;
22374 int res1 = 0 ;
22375 PyObject *swig_obj[1] ;
22376
22377 if (!args) SWIG_fail;
22378 swig_obj[0] = args;
22379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22380 if (!SWIG_IsOK(res1)) {
22381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22382 }
22383 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22384 {
22385 PyThreadState* __tstate = wxPyBeginAllowThreads();
22386 result = (int)((wxKeyEvent const *)arg1)->GetX();
22387 wxPyEndAllowThreads(__tstate);
22388 if (PyErr_Occurred()) SWIG_fail;
22389 }
22390 resultobj = SWIG_From_int(static_cast< int >(result));
22391 return resultobj;
22392 fail:
22393 return NULL;
22394 }
22395
22396
22397 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22398 PyObject *resultobj = 0;
22399 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22400 int result;
22401 void *argp1 = 0 ;
22402 int res1 = 0 ;
22403 PyObject *swig_obj[1] ;
22404
22405 if (!args) SWIG_fail;
22406 swig_obj[0] = args;
22407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22408 if (!SWIG_IsOK(res1)) {
22409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22410 }
22411 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22412 {
22413 PyThreadState* __tstate = wxPyBeginAllowThreads();
22414 result = (int)((wxKeyEvent const *)arg1)->GetY();
22415 wxPyEndAllowThreads(__tstate);
22416 if (PyErr_Occurred()) SWIG_fail;
22417 }
22418 resultobj = SWIG_From_int(static_cast< int >(result));
22419 return resultobj;
22420 fail:
22421 return NULL;
22422 }
22423
22424
22425 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22426 PyObject *resultobj = 0;
22427 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22428 int arg2 ;
22429 void *argp1 = 0 ;
22430 int res1 = 0 ;
22431 int val2 ;
22432 int ecode2 = 0 ;
22433 PyObject *swig_obj[2] ;
22434
22435 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22437 if (!SWIG_IsOK(res1)) {
22438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22439 }
22440 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22441 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22442 if (!SWIG_IsOK(ecode2)) {
22443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22444 }
22445 arg2 = static_cast< int >(val2);
22446 if (arg1) (arg1)->m_x = arg2;
22447
22448 resultobj = SWIG_Py_Void();
22449 return resultobj;
22450 fail:
22451 return NULL;
22452 }
22453
22454
22455 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22456 PyObject *resultobj = 0;
22457 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22458 int result;
22459 void *argp1 = 0 ;
22460 int res1 = 0 ;
22461 PyObject *swig_obj[1] ;
22462
22463 if (!args) SWIG_fail;
22464 swig_obj[0] = args;
22465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22466 if (!SWIG_IsOK(res1)) {
22467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22468 }
22469 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22470 result = (int) ((arg1)->m_x);
22471 resultobj = SWIG_From_int(static_cast< int >(result));
22472 return resultobj;
22473 fail:
22474 return NULL;
22475 }
22476
22477
22478 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22479 PyObject *resultobj = 0;
22480 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22481 int arg2 ;
22482 void *argp1 = 0 ;
22483 int res1 = 0 ;
22484 int val2 ;
22485 int ecode2 = 0 ;
22486 PyObject *swig_obj[2] ;
22487
22488 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22490 if (!SWIG_IsOK(res1)) {
22491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22492 }
22493 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22494 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22495 if (!SWIG_IsOK(ecode2)) {
22496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22497 }
22498 arg2 = static_cast< int >(val2);
22499 if (arg1) (arg1)->m_y = arg2;
22500
22501 resultobj = SWIG_Py_Void();
22502 return resultobj;
22503 fail:
22504 return NULL;
22505 }
22506
22507
22508 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22509 PyObject *resultobj = 0;
22510 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22511 int result;
22512 void *argp1 = 0 ;
22513 int res1 = 0 ;
22514 PyObject *swig_obj[1] ;
22515
22516 if (!args) SWIG_fail;
22517 swig_obj[0] = args;
22518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22519 if (!SWIG_IsOK(res1)) {
22520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22521 }
22522 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22523 result = (int) ((arg1)->m_y);
22524 resultobj = SWIG_From_int(static_cast< int >(result));
22525 return resultobj;
22526 fail:
22527 return NULL;
22528 }
22529
22530
22531 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22532 PyObject *resultobj = 0;
22533 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22534 long arg2 ;
22535 void *argp1 = 0 ;
22536 int res1 = 0 ;
22537 long val2 ;
22538 int ecode2 = 0 ;
22539 PyObject *swig_obj[2] ;
22540
22541 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22543 if (!SWIG_IsOK(res1)) {
22544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22545 }
22546 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22547 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22548 if (!SWIG_IsOK(ecode2)) {
22549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22550 }
22551 arg2 = static_cast< long >(val2);
22552 if (arg1) (arg1)->m_keyCode = arg2;
22553
22554 resultobj = SWIG_Py_Void();
22555 return resultobj;
22556 fail:
22557 return NULL;
22558 }
22559
22560
22561 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22562 PyObject *resultobj = 0;
22563 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22564 long result;
22565 void *argp1 = 0 ;
22566 int res1 = 0 ;
22567 PyObject *swig_obj[1] ;
22568
22569 if (!args) SWIG_fail;
22570 swig_obj[0] = args;
22571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22572 if (!SWIG_IsOK(res1)) {
22573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22574 }
22575 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22576 result = (long) ((arg1)->m_keyCode);
22577 resultobj = SWIG_From_long(static_cast< long >(result));
22578 return resultobj;
22579 fail:
22580 return NULL;
22581 }
22582
22583
22584 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22585 PyObject *resultobj = 0;
22586 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22587 bool arg2 ;
22588 void *argp1 = 0 ;
22589 int res1 = 0 ;
22590 bool val2 ;
22591 int ecode2 = 0 ;
22592 PyObject *swig_obj[2] ;
22593
22594 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22596 if (!SWIG_IsOK(res1)) {
22597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22598 }
22599 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22600 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22601 if (!SWIG_IsOK(ecode2)) {
22602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22603 }
22604 arg2 = static_cast< bool >(val2);
22605 if (arg1) (arg1)->m_controlDown = arg2;
22606
22607 resultobj = SWIG_Py_Void();
22608 return resultobj;
22609 fail:
22610 return NULL;
22611 }
22612
22613
22614 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615 PyObject *resultobj = 0;
22616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22617 bool result;
22618 void *argp1 = 0 ;
22619 int res1 = 0 ;
22620 PyObject *swig_obj[1] ;
22621
22622 if (!args) SWIG_fail;
22623 swig_obj[0] = args;
22624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22625 if (!SWIG_IsOK(res1)) {
22626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22627 }
22628 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22629 result = (bool) ((arg1)->m_controlDown);
22630 {
22631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22632 }
22633 return resultobj;
22634 fail:
22635 return NULL;
22636 }
22637
22638
22639 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22640 PyObject *resultobj = 0;
22641 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22642 bool arg2 ;
22643 void *argp1 = 0 ;
22644 int res1 = 0 ;
22645 bool val2 ;
22646 int ecode2 = 0 ;
22647 PyObject *swig_obj[2] ;
22648
22649 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22651 if (!SWIG_IsOK(res1)) {
22652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22653 }
22654 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22655 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22656 if (!SWIG_IsOK(ecode2)) {
22657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22658 }
22659 arg2 = static_cast< bool >(val2);
22660 if (arg1) (arg1)->m_shiftDown = arg2;
22661
22662 resultobj = SWIG_Py_Void();
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22670 PyObject *resultobj = 0;
22671 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22672 bool result;
22673 void *argp1 = 0 ;
22674 int res1 = 0 ;
22675 PyObject *swig_obj[1] ;
22676
22677 if (!args) SWIG_fail;
22678 swig_obj[0] = args;
22679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22680 if (!SWIG_IsOK(res1)) {
22681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22682 }
22683 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22684 result = (bool) ((arg1)->m_shiftDown);
22685 {
22686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22687 }
22688 return resultobj;
22689 fail:
22690 return NULL;
22691 }
22692
22693
22694 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22695 PyObject *resultobj = 0;
22696 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22697 bool arg2 ;
22698 void *argp1 = 0 ;
22699 int res1 = 0 ;
22700 bool val2 ;
22701 int ecode2 = 0 ;
22702 PyObject *swig_obj[2] ;
22703
22704 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22706 if (!SWIG_IsOK(res1)) {
22707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22708 }
22709 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22710 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22711 if (!SWIG_IsOK(ecode2)) {
22712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22713 }
22714 arg2 = static_cast< bool >(val2);
22715 if (arg1) (arg1)->m_altDown = arg2;
22716
22717 resultobj = SWIG_Py_Void();
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22725 PyObject *resultobj = 0;
22726 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22727 bool result;
22728 void *argp1 = 0 ;
22729 int res1 = 0 ;
22730 PyObject *swig_obj[1] ;
22731
22732 if (!args) SWIG_fail;
22733 swig_obj[0] = args;
22734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22735 if (!SWIG_IsOK(res1)) {
22736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22737 }
22738 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22739 result = (bool) ((arg1)->m_altDown);
22740 {
22741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22742 }
22743 return resultobj;
22744 fail:
22745 return NULL;
22746 }
22747
22748
22749 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22750 PyObject *resultobj = 0;
22751 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22752 bool arg2 ;
22753 void *argp1 = 0 ;
22754 int res1 = 0 ;
22755 bool val2 ;
22756 int ecode2 = 0 ;
22757 PyObject *swig_obj[2] ;
22758
22759 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22761 if (!SWIG_IsOK(res1)) {
22762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22763 }
22764 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22765 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22766 if (!SWIG_IsOK(ecode2)) {
22767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22768 }
22769 arg2 = static_cast< bool >(val2);
22770 if (arg1) (arg1)->m_metaDown = arg2;
22771
22772 resultobj = SWIG_Py_Void();
22773 return resultobj;
22774 fail:
22775 return NULL;
22776 }
22777
22778
22779 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22780 PyObject *resultobj = 0;
22781 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22782 bool result;
22783 void *argp1 = 0 ;
22784 int res1 = 0 ;
22785 PyObject *swig_obj[1] ;
22786
22787 if (!args) SWIG_fail;
22788 swig_obj[0] = args;
22789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22790 if (!SWIG_IsOK(res1)) {
22791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22792 }
22793 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22794 result = (bool) ((arg1)->m_metaDown);
22795 {
22796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22797 }
22798 return resultobj;
22799 fail:
22800 return NULL;
22801 }
22802
22803
22804 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22805 PyObject *resultobj = 0;
22806 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22807 bool arg2 ;
22808 void *argp1 = 0 ;
22809 int res1 = 0 ;
22810 bool val2 ;
22811 int ecode2 = 0 ;
22812 PyObject *swig_obj[2] ;
22813
22814 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22816 if (!SWIG_IsOK(res1)) {
22817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22818 }
22819 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22820 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22821 if (!SWIG_IsOK(ecode2)) {
22822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22823 }
22824 arg2 = static_cast< bool >(val2);
22825 if (arg1) (arg1)->m_scanCode = arg2;
22826
22827 resultobj = SWIG_Py_Void();
22828 return resultobj;
22829 fail:
22830 return NULL;
22831 }
22832
22833
22834 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22835 PyObject *resultobj = 0;
22836 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22837 bool result;
22838 void *argp1 = 0 ;
22839 int res1 = 0 ;
22840 PyObject *swig_obj[1] ;
22841
22842 if (!args) SWIG_fail;
22843 swig_obj[0] = args;
22844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22845 if (!SWIG_IsOK(res1)) {
22846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22847 }
22848 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22849 result = (bool) ((arg1)->m_scanCode);
22850 {
22851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22852 }
22853 return resultobj;
22854 fail:
22855 return NULL;
22856 }
22857
22858
22859 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22860 PyObject *resultobj = 0;
22861 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22862 unsigned int arg2 ;
22863 void *argp1 = 0 ;
22864 int res1 = 0 ;
22865 unsigned int val2 ;
22866 int ecode2 = 0 ;
22867 PyObject *swig_obj[2] ;
22868
22869 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22871 if (!SWIG_IsOK(res1)) {
22872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22873 }
22874 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22875 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22876 if (!SWIG_IsOK(ecode2)) {
22877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22878 }
22879 arg2 = static_cast< unsigned int >(val2);
22880 if (arg1) (arg1)->m_rawCode = arg2;
22881
22882 resultobj = SWIG_Py_Void();
22883 return resultobj;
22884 fail:
22885 return NULL;
22886 }
22887
22888
22889 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22890 PyObject *resultobj = 0;
22891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22892 unsigned int result;
22893 void *argp1 = 0 ;
22894 int res1 = 0 ;
22895 PyObject *swig_obj[1] ;
22896
22897 if (!args) SWIG_fail;
22898 swig_obj[0] = args;
22899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22900 if (!SWIG_IsOK(res1)) {
22901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22902 }
22903 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22904 result = (unsigned int) ((arg1)->m_rawCode);
22905 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22913 PyObject *resultobj = 0;
22914 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22915 unsigned int arg2 ;
22916 void *argp1 = 0 ;
22917 int res1 = 0 ;
22918 unsigned int val2 ;
22919 int ecode2 = 0 ;
22920 PyObject *swig_obj[2] ;
22921
22922 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22924 if (!SWIG_IsOK(res1)) {
22925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22926 }
22927 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22928 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22929 if (!SWIG_IsOK(ecode2)) {
22930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22931 }
22932 arg2 = static_cast< unsigned int >(val2);
22933 if (arg1) (arg1)->m_rawFlags = arg2;
22934
22935 resultobj = SWIG_Py_Void();
22936 return resultobj;
22937 fail:
22938 return NULL;
22939 }
22940
22941
22942 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22943 PyObject *resultobj = 0;
22944 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22945 unsigned int result;
22946 void *argp1 = 0 ;
22947 int res1 = 0 ;
22948 PyObject *swig_obj[1] ;
22949
22950 if (!args) SWIG_fail;
22951 swig_obj[0] = args;
22952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22953 if (!SWIG_IsOK(res1)) {
22954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22955 }
22956 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22957 result = (unsigned int) ((arg1)->m_rawFlags);
22958 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22959 return resultobj;
22960 fail:
22961 return NULL;
22962 }
22963
22964
22965 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22966 PyObject *obj;
22967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22968 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22969 return SWIG_Py_Void();
22970 }
22971
22972 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22973 return SWIG_Python_InitShadowInstance(args);
22974 }
22975
22976 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22977 PyObject *resultobj = 0;
22978 wxSize const &arg1_defvalue = wxDefaultSize ;
22979 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22980 int arg2 = (int) 0 ;
22981 wxSizeEvent *result = 0 ;
22982 wxSize temp1 ;
22983 int val2 ;
22984 int ecode2 = 0 ;
22985 PyObject * obj0 = 0 ;
22986 PyObject * obj1 = 0 ;
22987 char * kwnames[] = {
22988 (char *) "sz",(char *) "winid", NULL
22989 };
22990
22991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22992 if (obj0) {
22993 {
22994 arg1 = &temp1;
22995 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22996 }
22997 }
22998 if (obj1) {
22999 ecode2 = SWIG_AsVal_int(obj1, &val2);
23000 if (!SWIG_IsOK(ecode2)) {
23001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23002 }
23003 arg2 = static_cast< int >(val2);
23004 }
23005 {
23006 PyThreadState* __tstate = wxPyBeginAllowThreads();
23007 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23012 return resultobj;
23013 fail:
23014 return NULL;
23015 }
23016
23017
23018 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23019 PyObject *resultobj = 0;
23020 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23021 wxSize result;
23022 void *argp1 = 0 ;
23023 int res1 = 0 ;
23024 PyObject *swig_obj[1] ;
23025
23026 if (!args) SWIG_fail;
23027 swig_obj[0] = args;
23028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23029 if (!SWIG_IsOK(res1)) {
23030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23031 }
23032 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23033 {
23034 PyThreadState* __tstate = wxPyBeginAllowThreads();
23035 result = ((wxSizeEvent const *)arg1)->GetSize();
23036 wxPyEndAllowThreads(__tstate);
23037 if (PyErr_Occurred()) SWIG_fail;
23038 }
23039 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23040 return resultobj;
23041 fail:
23042 return NULL;
23043 }
23044
23045
23046 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23047 PyObject *resultobj = 0;
23048 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23049 wxRect result;
23050 void *argp1 = 0 ;
23051 int res1 = 0 ;
23052 PyObject *swig_obj[1] ;
23053
23054 if (!args) SWIG_fail;
23055 swig_obj[0] = args;
23056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23057 if (!SWIG_IsOK(res1)) {
23058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23059 }
23060 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23061 {
23062 PyThreadState* __tstate = wxPyBeginAllowThreads();
23063 result = ((wxSizeEvent const *)arg1)->GetRect();
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23068 return resultobj;
23069 fail:
23070 return NULL;
23071 }
23072
23073
23074 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23075 PyObject *resultobj = 0;
23076 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23077 wxRect arg2 ;
23078 void *argp1 = 0 ;
23079 int res1 = 0 ;
23080 void *argp2 ;
23081 int res2 = 0 ;
23082 PyObject * obj0 = 0 ;
23083 PyObject * obj1 = 0 ;
23084 char * kwnames[] = {
23085 (char *) "self",(char *) "rect", NULL
23086 };
23087
23088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23090 if (!SWIG_IsOK(res1)) {
23091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23092 }
23093 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23094 {
23095 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23096 if (!SWIG_IsOK(res2)) {
23097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23098 }
23099 if (!argp2) {
23100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23101 } else {
23102 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23103 arg2 = *temp;
23104 if (SWIG_IsNewObj(res2)) delete temp;
23105 }
23106 }
23107 {
23108 PyThreadState* __tstate = wxPyBeginAllowThreads();
23109 (arg1)->SetRect(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 *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23121 PyObject *resultobj = 0;
23122 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23123 wxSize arg2 ;
23124 void *argp1 = 0 ;
23125 int res1 = 0 ;
23126 void *argp2 ;
23127 int res2 = 0 ;
23128 PyObject * obj0 = 0 ;
23129 PyObject * obj1 = 0 ;
23130 char * kwnames[] = {
23131 (char *) "self",(char *) "size", NULL
23132 };
23133
23134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23136 if (!SWIG_IsOK(res1)) {
23137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23138 }
23139 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23140 {
23141 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23142 if (!SWIG_IsOK(res2)) {
23143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23144 }
23145 if (!argp2) {
23146 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23147 } else {
23148 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23149 arg2 = *temp;
23150 if (SWIG_IsNewObj(res2)) delete temp;
23151 }
23152 }
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 wxSizeEvent_SetSize(arg1,arg2);
23156 wxPyEndAllowThreads(__tstate);
23157 if (PyErr_Occurred()) SWIG_fail;
23158 }
23159 resultobj = SWIG_Py_Void();
23160 return resultobj;
23161 fail:
23162 return NULL;
23163 }
23164
23165
23166 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23167 PyObject *resultobj = 0;
23168 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23169 wxSize *arg2 = (wxSize *) 0 ;
23170 void *argp1 = 0 ;
23171 int res1 = 0 ;
23172 void *argp2 = 0 ;
23173 int res2 = 0 ;
23174 PyObject *swig_obj[2] ;
23175
23176 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23178 if (!SWIG_IsOK(res1)) {
23179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23180 }
23181 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23182 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23183 if (!SWIG_IsOK(res2)) {
23184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23185 }
23186 arg2 = reinterpret_cast< wxSize * >(argp2);
23187 if (arg1) (arg1)->m_size = *arg2;
23188
23189 resultobj = SWIG_Py_Void();
23190 return resultobj;
23191 fail:
23192 return NULL;
23193 }
23194
23195
23196 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23197 PyObject *resultobj = 0;
23198 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23199 wxSize *result = 0 ;
23200 void *argp1 = 0 ;
23201 int res1 = 0 ;
23202 PyObject *swig_obj[1] ;
23203
23204 if (!args) SWIG_fail;
23205 swig_obj[0] = args;
23206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23207 if (!SWIG_IsOK(res1)) {
23208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23209 }
23210 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23211 result = (wxSize *)& ((arg1)->m_size);
23212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23213 return resultobj;
23214 fail:
23215 return NULL;
23216 }
23217
23218
23219 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23220 PyObject *resultobj = 0;
23221 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23222 wxRect *arg2 = (wxRect *) 0 ;
23223 void *argp1 = 0 ;
23224 int res1 = 0 ;
23225 void *argp2 = 0 ;
23226 int res2 = 0 ;
23227 PyObject *swig_obj[2] ;
23228
23229 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23231 if (!SWIG_IsOK(res1)) {
23232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23233 }
23234 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23235 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23236 if (!SWIG_IsOK(res2)) {
23237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23238 }
23239 arg2 = reinterpret_cast< wxRect * >(argp2);
23240 if (arg1) (arg1)->m_rect = *arg2;
23241
23242 resultobj = SWIG_Py_Void();
23243 return resultobj;
23244 fail:
23245 return NULL;
23246 }
23247
23248
23249 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23250 PyObject *resultobj = 0;
23251 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23252 wxRect *result = 0 ;
23253 void *argp1 = 0 ;
23254 int res1 = 0 ;
23255 PyObject *swig_obj[1] ;
23256
23257 if (!args) SWIG_fail;
23258 swig_obj[0] = args;
23259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23260 if (!SWIG_IsOK(res1)) {
23261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23262 }
23263 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23264 result = (wxRect *)& ((arg1)->m_rect);
23265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23266 return resultobj;
23267 fail:
23268 return NULL;
23269 }
23270
23271
23272 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23273 PyObject *obj;
23274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23275 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23276 return SWIG_Py_Void();
23277 }
23278
23279 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23280 return SWIG_Python_InitShadowInstance(args);
23281 }
23282
23283 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23284 PyObject *resultobj = 0;
23285 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23286 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23287 int arg2 = (int) 0 ;
23288 wxMoveEvent *result = 0 ;
23289 wxPoint temp1 ;
23290 int val2 ;
23291 int ecode2 = 0 ;
23292 PyObject * obj0 = 0 ;
23293 PyObject * obj1 = 0 ;
23294 char * kwnames[] = {
23295 (char *) "pos",(char *) "winid", NULL
23296 };
23297
23298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23299 if (obj0) {
23300 {
23301 arg1 = &temp1;
23302 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23303 }
23304 }
23305 if (obj1) {
23306 ecode2 = SWIG_AsVal_int(obj1, &val2);
23307 if (!SWIG_IsOK(ecode2)) {
23308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23309 }
23310 arg2 = static_cast< int >(val2);
23311 }
23312 {
23313 PyThreadState* __tstate = wxPyBeginAllowThreads();
23314 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23315 wxPyEndAllowThreads(__tstate);
23316 if (PyErr_Occurred()) SWIG_fail;
23317 }
23318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23319 return resultobj;
23320 fail:
23321 return NULL;
23322 }
23323
23324
23325 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23326 PyObject *resultobj = 0;
23327 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23328 wxPoint result;
23329 void *argp1 = 0 ;
23330 int res1 = 0 ;
23331 PyObject *swig_obj[1] ;
23332
23333 if (!args) SWIG_fail;
23334 swig_obj[0] = args;
23335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23336 if (!SWIG_IsOK(res1)) {
23337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23338 }
23339 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23340 {
23341 PyThreadState* __tstate = wxPyBeginAllowThreads();
23342 result = ((wxMoveEvent const *)arg1)->GetPosition();
23343 wxPyEndAllowThreads(__tstate);
23344 if (PyErr_Occurred()) SWIG_fail;
23345 }
23346 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23347 return resultobj;
23348 fail:
23349 return NULL;
23350 }
23351
23352
23353 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23354 PyObject *resultobj = 0;
23355 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23356 wxRect result;
23357 void *argp1 = 0 ;
23358 int res1 = 0 ;
23359 PyObject *swig_obj[1] ;
23360
23361 if (!args) SWIG_fail;
23362 swig_obj[0] = args;
23363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23364 if (!SWIG_IsOK(res1)) {
23365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23366 }
23367 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 result = ((wxMoveEvent const *)arg1)->GetRect();
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23382 PyObject *resultobj = 0;
23383 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23384 wxRect *arg2 = 0 ;
23385 void *argp1 = 0 ;
23386 int res1 = 0 ;
23387 wxRect temp2 ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char * kwnames[] = {
23391 (char *) "self",(char *) "rect", NULL
23392 };
23393
23394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23396 if (!SWIG_IsOK(res1)) {
23397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23398 }
23399 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23400 {
23401 arg2 = &temp2;
23402 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23403 }
23404 {
23405 PyThreadState* __tstate = wxPyBeginAllowThreads();
23406 (arg1)->SetRect((wxRect const &)*arg2);
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 resultobj = SWIG_Py_Void();
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj = 0;
23419 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23420 wxPoint *arg2 = 0 ;
23421 void *argp1 = 0 ;
23422 int res1 = 0 ;
23423 wxPoint temp2 ;
23424 PyObject * obj0 = 0 ;
23425 PyObject * obj1 = 0 ;
23426 char * kwnames[] = {
23427 (char *) "self",(char *) "pos", NULL
23428 };
23429
23430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23432 if (!SWIG_IsOK(res1)) {
23433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23434 }
23435 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23436 {
23437 arg2 = &temp2;
23438 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23439 }
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 (arg1)->SetPosition((wxPoint const &)*arg2);
23443 wxPyEndAllowThreads(__tstate);
23444 if (PyErr_Occurred()) SWIG_fail;
23445 }
23446 resultobj = SWIG_Py_Void();
23447 return resultobj;
23448 fail:
23449 return NULL;
23450 }
23451
23452
23453 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23454 PyObject *obj;
23455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23456 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23457 return SWIG_Py_Void();
23458 }
23459
23460 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23461 return SWIG_Python_InitShadowInstance(args);
23462 }
23463
23464 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23465 PyObject *resultobj = 0;
23466 int arg1 = (int) 0 ;
23467 wxPaintEvent *result = 0 ;
23468 int val1 ;
23469 int ecode1 = 0 ;
23470 PyObject * obj0 = 0 ;
23471 char * kwnames[] = {
23472 (char *) "Id", NULL
23473 };
23474
23475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23476 if (obj0) {
23477 ecode1 = SWIG_AsVal_int(obj0, &val1);
23478 if (!SWIG_IsOK(ecode1)) {
23479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23480 }
23481 arg1 = static_cast< int >(val1);
23482 }
23483 {
23484 PyThreadState* __tstate = wxPyBeginAllowThreads();
23485 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23486 wxPyEndAllowThreads(__tstate);
23487 if (PyErr_Occurred()) SWIG_fail;
23488 }
23489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23490 return resultobj;
23491 fail:
23492 return NULL;
23493 }
23494
23495
23496 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23497 PyObject *obj;
23498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23499 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23500 return SWIG_Py_Void();
23501 }
23502
23503 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23504 return SWIG_Python_InitShadowInstance(args);
23505 }
23506
23507 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23508 PyObject *resultobj = 0;
23509 int arg1 = (int) 0 ;
23510 wxNcPaintEvent *result = 0 ;
23511 int val1 ;
23512 int ecode1 = 0 ;
23513 PyObject * obj0 = 0 ;
23514 char * kwnames[] = {
23515 (char *) "winid", NULL
23516 };
23517
23518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23519 if (obj0) {
23520 ecode1 = SWIG_AsVal_int(obj0, &val1);
23521 if (!SWIG_IsOK(ecode1)) {
23522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23523 }
23524 arg1 = static_cast< int >(val1);
23525 }
23526 {
23527 PyThreadState* __tstate = wxPyBeginAllowThreads();
23528 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23533 return resultobj;
23534 fail:
23535 return NULL;
23536 }
23537
23538
23539 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23540 PyObject *obj;
23541 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23542 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23543 return SWIG_Py_Void();
23544 }
23545
23546 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23547 return SWIG_Python_InitShadowInstance(args);
23548 }
23549
23550 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23551 PyObject *resultobj = 0;
23552 int arg1 = (int) 0 ;
23553 wxDC *arg2 = (wxDC *) NULL ;
23554 wxEraseEvent *result = 0 ;
23555 int val1 ;
23556 int ecode1 = 0 ;
23557 void *argp2 = 0 ;
23558 int res2 = 0 ;
23559 PyObject * obj0 = 0 ;
23560 PyObject * obj1 = 0 ;
23561 char * kwnames[] = {
23562 (char *) "Id",(char *) "dc", NULL
23563 };
23564
23565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23566 if (obj0) {
23567 ecode1 = SWIG_AsVal_int(obj0, &val1);
23568 if (!SWIG_IsOK(ecode1)) {
23569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23570 }
23571 arg1 = static_cast< int >(val1);
23572 }
23573 if (obj1) {
23574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23575 if (!SWIG_IsOK(res2)) {
23576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23577 }
23578 arg2 = reinterpret_cast< wxDC * >(argp2);
23579 }
23580 {
23581 PyThreadState* __tstate = wxPyBeginAllowThreads();
23582 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23583 wxPyEndAllowThreads(__tstate);
23584 if (PyErr_Occurred()) SWIG_fail;
23585 }
23586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23587 return resultobj;
23588 fail:
23589 return NULL;
23590 }
23591
23592
23593 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23594 PyObject *resultobj = 0;
23595 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23596 wxDC *result = 0 ;
23597 void *argp1 = 0 ;
23598 int res1 = 0 ;
23599 PyObject *swig_obj[1] ;
23600
23601 if (!args) SWIG_fail;
23602 swig_obj[0] = args;
23603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23604 if (!SWIG_IsOK(res1)) {
23605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23606 }
23607 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23608 {
23609 PyThreadState* __tstate = wxPyBeginAllowThreads();
23610 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23611 wxPyEndAllowThreads(__tstate);
23612 if (PyErr_Occurred()) SWIG_fail;
23613 }
23614 {
23615 resultobj = wxPyMake_wxObject(result, (bool)0);
23616 }
23617 return resultobj;
23618 fail:
23619 return NULL;
23620 }
23621
23622
23623 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23624 PyObject *obj;
23625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23626 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23627 return SWIG_Py_Void();
23628 }
23629
23630 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23631 return SWIG_Python_InitShadowInstance(args);
23632 }
23633
23634 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23635 PyObject *resultobj = 0;
23636 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23637 int arg2 = (int) 0 ;
23638 wxFocusEvent *result = 0 ;
23639 int val1 ;
23640 int ecode1 = 0 ;
23641 int val2 ;
23642 int ecode2 = 0 ;
23643 PyObject * obj0 = 0 ;
23644 PyObject * obj1 = 0 ;
23645 char * kwnames[] = {
23646 (char *) "type",(char *) "winid", NULL
23647 };
23648
23649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23650 if (obj0) {
23651 ecode1 = SWIG_AsVal_int(obj0, &val1);
23652 if (!SWIG_IsOK(ecode1)) {
23653 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23654 }
23655 arg1 = static_cast< wxEventType >(val1);
23656 }
23657 if (obj1) {
23658 ecode2 = SWIG_AsVal_int(obj1, &val2);
23659 if (!SWIG_IsOK(ecode2)) {
23660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23661 }
23662 arg2 = static_cast< int >(val2);
23663 }
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23678 PyObject *resultobj = 0;
23679 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23680 wxWindow *result = 0 ;
23681 void *argp1 = 0 ;
23682 int res1 = 0 ;
23683 PyObject *swig_obj[1] ;
23684
23685 if (!args) SWIG_fail;
23686 swig_obj[0] = args;
23687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23688 if (!SWIG_IsOK(res1)) {
23689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23690 }
23691 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23695 wxPyEndAllowThreads(__tstate);
23696 if (PyErr_Occurred()) SWIG_fail;
23697 }
23698 {
23699 resultobj = wxPyMake_wxObject(result, (bool)0);
23700 }
23701 return resultobj;
23702 fail:
23703 return NULL;
23704 }
23705
23706
23707 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23708 PyObject *resultobj = 0;
23709 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23710 wxWindow *arg2 = (wxWindow *) 0 ;
23711 void *argp1 = 0 ;
23712 int res1 = 0 ;
23713 void *argp2 = 0 ;
23714 int res2 = 0 ;
23715 PyObject * obj0 = 0 ;
23716 PyObject * obj1 = 0 ;
23717 char * kwnames[] = {
23718 (char *) "self",(char *) "win", NULL
23719 };
23720
23721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23723 if (!SWIG_IsOK(res1)) {
23724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23725 }
23726 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23728 if (!SWIG_IsOK(res2)) {
23729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23730 }
23731 arg2 = reinterpret_cast< wxWindow * >(argp2);
23732 {
23733 PyThreadState* __tstate = wxPyBeginAllowThreads();
23734 (arg1)->SetWindow(arg2);
23735 wxPyEndAllowThreads(__tstate);
23736 if (PyErr_Occurred()) SWIG_fail;
23737 }
23738 resultobj = SWIG_Py_Void();
23739 return resultobj;
23740 fail:
23741 return NULL;
23742 }
23743
23744
23745 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23746 PyObject *obj;
23747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23748 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23749 return SWIG_Py_Void();
23750 }
23751
23752 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23753 return SWIG_Python_InitShadowInstance(args);
23754 }
23755
23756 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23757 PyObject *resultobj = 0;
23758 wxWindow *arg1 = (wxWindow *) NULL ;
23759 wxChildFocusEvent *result = 0 ;
23760 void *argp1 = 0 ;
23761 int res1 = 0 ;
23762 PyObject * obj0 = 0 ;
23763 char * kwnames[] = {
23764 (char *) "win", NULL
23765 };
23766
23767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23768 if (obj0) {
23769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23770 if (!SWIG_IsOK(res1)) {
23771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23772 }
23773 arg1 = reinterpret_cast< wxWindow * >(argp1);
23774 }
23775 {
23776 PyThreadState* __tstate = wxPyBeginAllowThreads();
23777 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23782 return resultobj;
23783 fail:
23784 return NULL;
23785 }
23786
23787
23788 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23789 PyObject *resultobj = 0;
23790 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23791 wxWindow *result = 0 ;
23792 void *argp1 = 0 ;
23793 int res1 = 0 ;
23794 PyObject *swig_obj[1] ;
23795
23796 if (!args) SWIG_fail;
23797 swig_obj[0] = args;
23798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23799 if (!SWIG_IsOK(res1)) {
23800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23801 }
23802 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23803 {
23804 PyThreadState* __tstate = wxPyBeginAllowThreads();
23805 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 {
23810 resultobj = wxPyMake_wxObject(result, (bool)0);
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23819 PyObject *obj;
23820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23821 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23822 return SWIG_Py_Void();
23823 }
23824
23825 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 return SWIG_Python_InitShadowInstance(args);
23827 }
23828
23829 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23830 PyObject *resultobj = 0;
23831 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23832 bool arg2 = (bool) true ;
23833 int arg3 = (int) 0 ;
23834 wxActivateEvent *result = 0 ;
23835 int val1 ;
23836 int ecode1 = 0 ;
23837 bool val2 ;
23838 int ecode2 = 0 ;
23839 int val3 ;
23840 int ecode3 = 0 ;
23841 PyObject * obj0 = 0 ;
23842 PyObject * obj1 = 0 ;
23843 PyObject * obj2 = 0 ;
23844 char * kwnames[] = {
23845 (char *) "type",(char *) "active",(char *) "Id", NULL
23846 };
23847
23848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23849 if (obj0) {
23850 ecode1 = SWIG_AsVal_int(obj0, &val1);
23851 if (!SWIG_IsOK(ecode1)) {
23852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23853 }
23854 arg1 = static_cast< wxEventType >(val1);
23855 }
23856 if (obj1) {
23857 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23858 if (!SWIG_IsOK(ecode2)) {
23859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23860 }
23861 arg2 = static_cast< bool >(val2);
23862 }
23863 if (obj2) {
23864 ecode3 = SWIG_AsVal_int(obj2, &val3);
23865 if (!SWIG_IsOK(ecode3)) {
23866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23867 }
23868 arg3 = static_cast< int >(val3);
23869 }
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *resultobj = 0;
23885 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23886 bool result;
23887 void *argp1 = 0 ;
23888 int res1 = 0 ;
23889 PyObject *swig_obj[1] ;
23890
23891 if (!args) SWIG_fail;
23892 swig_obj[0] = args;
23893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23894 if (!SWIG_IsOK(res1)) {
23895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23896 }
23897 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 {
23905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23906 }
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23914 PyObject *obj;
23915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23916 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23917 return SWIG_Py_Void();
23918 }
23919
23920 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23921 return SWIG_Python_InitShadowInstance(args);
23922 }
23923
23924 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23925 PyObject *resultobj = 0;
23926 int arg1 = (int) 0 ;
23927 wxInitDialogEvent *result = 0 ;
23928 int val1 ;
23929 int ecode1 = 0 ;
23930 PyObject * obj0 = 0 ;
23931 char * kwnames[] = {
23932 (char *) "Id", NULL
23933 };
23934
23935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23936 if (obj0) {
23937 ecode1 = SWIG_AsVal_int(obj0, &val1);
23938 if (!SWIG_IsOK(ecode1)) {
23939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23940 }
23941 arg1 = static_cast< int >(val1);
23942 }
23943 {
23944 PyThreadState* __tstate = wxPyBeginAllowThreads();
23945 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23946 wxPyEndAllowThreads(__tstate);
23947 if (PyErr_Occurred()) SWIG_fail;
23948 }
23949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23950 return resultobj;
23951 fail:
23952 return NULL;
23953 }
23954
23955
23956 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23957 PyObject *obj;
23958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23959 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23960 return SWIG_Py_Void();
23961 }
23962
23963 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23964 return SWIG_Python_InitShadowInstance(args);
23965 }
23966
23967 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = 0;
23969 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23970 int arg2 = (int) 0 ;
23971 wxMenu *arg3 = (wxMenu *) NULL ;
23972 wxMenuEvent *result = 0 ;
23973 int val1 ;
23974 int ecode1 = 0 ;
23975 int val2 ;
23976 int ecode2 = 0 ;
23977 void *argp3 = 0 ;
23978 int res3 = 0 ;
23979 PyObject * obj0 = 0 ;
23980 PyObject * obj1 = 0 ;
23981 PyObject * obj2 = 0 ;
23982 char * kwnames[] = {
23983 (char *) "type",(char *) "winid",(char *) "menu", NULL
23984 };
23985
23986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23987 if (obj0) {
23988 ecode1 = SWIG_AsVal_int(obj0, &val1);
23989 if (!SWIG_IsOK(ecode1)) {
23990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23991 }
23992 arg1 = static_cast< wxEventType >(val1);
23993 }
23994 if (obj1) {
23995 ecode2 = SWIG_AsVal_int(obj1, &val2);
23996 if (!SWIG_IsOK(ecode2)) {
23997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23998 }
23999 arg2 = static_cast< int >(val2);
24000 }
24001 if (obj2) {
24002 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24003 if (!SWIG_IsOK(res3)) {
24004 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24005 }
24006 arg3 = reinterpret_cast< wxMenu * >(argp3);
24007 }
24008 {
24009 PyThreadState* __tstate = wxPyBeginAllowThreads();
24010 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24011 wxPyEndAllowThreads(__tstate);
24012 if (PyErr_Occurred()) SWIG_fail;
24013 }
24014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24024 int result;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 PyObject *swig_obj[1] ;
24028
24029 if (!args) SWIG_fail;
24030 swig_obj[0] = args;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24034 }
24035 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 resultobj = SWIG_From_int(static_cast< int >(result));
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24050 PyObject *resultobj = 0;
24051 wxMenuEvent *arg1 = (wxMenuEvent *) 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_wxMenuEvent, 0 | 0 );
24060 if (!SWIG_IsOK(res1)) {
24061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24062 }
24063 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
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_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24080 PyObject *resultobj = 0;
24081 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24082 wxMenu *result = 0 ;
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_wxMenuEvent, 0 | 0 );
24090 if (!SWIG_IsOK(res1)) {
24091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24092 }
24093 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24094 {
24095 PyThreadState* __tstate = wxPyBeginAllowThreads();
24096 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24097 wxPyEndAllowThreads(__tstate);
24098 if (PyErr_Occurred()) SWIG_fail;
24099 }
24100 {
24101 resultobj = wxPyMake_wxObject(result, (bool)0);
24102 }
24103 return resultobj;
24104 fail:
24105 return NULL;
24106 }
24107
24108
24109 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24110 PyObject *obj;
24111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24112 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24113 return SWIG_Py_Void();
24114 }
24115
24116 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24117 return SWIG_Python_InitShadowInstance(args);
24118 }
24119
24120 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24121 PyObject *resultobj = 0;
24122 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24123 int arg2 = (int) 0 ;
24124 wxCloseEvent *result = 0 ;
24125 int val1 ;
24126 int ecode1 = 0 ;
24127 int val2 ;
24128 int ecode2 = 0 ;
24129 PyObject * obj0 = 0 ;
24130 PyObject * obj1 = 0 ;
24131 char * kwnames[] = {
24132 (char *) "type",(char *) "winid", NULL
24133 };
24134
24135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24136 if (obj0) {
24137 ecode1 = SWIG_AsVal_int(obj0, &val1);
24138 if (!SWIG_IsOK(ecode1)) {
24139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24140 }
24141 arg1 = static_cast< wxEventType >(val1);
24142 }
24143 if (obj1) {
24144 ecode2 = SWIG_AsVal_int(obj1, &val2);
24145 if (!SWIG_IsOK(ecode2)) {
24146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24147 }
24148 arg2 = static_cast< int >(val2);
24149 }
24150 {
24151 PyThreadState* __tstate = wxPyBeginAllowThreads();
24152 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24153 wxPyEndAllowThreads(__tstate);
24154 if (PyErr_Occurred()) SWIG_fail;
24155 }
24156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj = 0;
24165 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24166 bool arg2 ;
24167 void *argp1 = 0 ;
24168 int res1 = 0 ;
24169 bool val2 ;
24170 int ecode2 = 0 ;
24171 PyObject * obj0 = 0 ;
24172 PyObject * obj1 = 0 ;
24173 char * kwnames[] = {
24174 (char *) "self",(char *) "logOff", NULL
24175 };
24176
24177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24179 if (!SWIG_IsOK(res1)) {
24180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24181 }
24182 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24183 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24184 if (!SWIG_IsOK(ecode2)) {
24185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24186 }
24187 arg2 = static_cast< bool >(val2);
24188 {
24189 PyThreadState* __tstate = wxPyBeginAllowThreads();
24190 (arg1)->SetLoggingOff(arg2);
24191 wxPyEndAllowThreads(__tstate);
24192 if (PyErr_Occurred()) SWIG_fail;
24193 }
24194 resultobj = SWIG_Py_Void();
24195 return resultobj;
24196 fail:
24197 return NULL;
24198 }
24199
24200
24201 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24202 PyObject *resultobj = 0;
24203 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24204 bool result;
24205 void *argp1 = 0 ;
24206 int res1 = 0 ;
24207 PyObject *swig_obj[1] ;
24208
24209 if (!args) SWIG_fail;
24210 swig_obj[0] = args;
24211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24212 if (!SWIG_IsOK(res1)) {
24213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24214 }
24215 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24219 wxPyEndAllowThreads(__tstate);
24220 if (PyErr_Occurred()) SWIG_fail;
24221 }
24222 {
24223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24224 }
24225 return resultobj;
24226 fail:
24227 return NULL;
24228 }
24229
24230
24231 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24232 PyObject *resultobj = 0;
24233 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24234 bool arg2 = (bool) true ;
24235 void *argp1 = 0 ;
24236 int res1 = 0 ;
24237 bool val2 ;
24238 int ecode2 = 0 ;
24239 PyObject * obj0 = 0 ;
24240 PyObject * obj1 = 0 ;
24241 char * kwnames[] = {
24242 (char *) "self",(char *) "veto", NULL
24243 };
24244
24245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24247 if (!SWIG_IsOK(res1)) {
24248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24249 }
24250 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24251 if (obj1) {
24252 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24253 if (!SWIG_IsOK(ecode2)) {
24254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24255 }
24256 arg2 = static_cast< bool >(val2);
24257 }
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 (arg1)->Veto(arg2);
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 resultobj = SWIG_Py_Void();
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24272 PyObject *resultobj = 0;
24273 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24274 bool result;
24275 void *argp1 = 0 ;
24276 int res1 = 0 ;
24277 PyObject *swig_obj[1] ;
24278
24279 if (!args) SWIG_fail;
24280 swig_obj[0] = args;
24281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24282 if (!SWIG_IsOK(res1)) {
24283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24284 }
24285 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24286 {
24287 PyThreadState* __tstate = wxPyBeginAllowThreads();
24288 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 {
24293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24294 }
24295 return resultobj;
24296 fail:
24297 return NULL;
24298 }
24299
24300
24301 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24302 PyObject *resultobj = 0;
24303 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24304 bool arg2 ;
24305 void *argp1 = 0 ;
24306 int res1 = 0 ;
24307 bool val2 ;
24308 int ecode2 = 0 ;
24309 PyObject * obj0 = 0 ;
24310 PyObject * obj1 = 0 ;
24311 char * kwnames[] = {
24312 (char *) "self",(char *) "canVeto", NULL
24313 };
24314
24315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24317 if (!SWIG_IsOK(res1)) {
24318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24319 }
24320 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24321 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24322 if (!SWIG_IsOK(ecode2)) {
24323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24324 }
24325 arg2 = static_cast< bool >(val2);
24326 {
24327 PyThreadState* __tstate = wxPyBeginAllowThreads();
24328 (arg1)->SetCanVeto(arg2);
24329 wxPyEndAllowThreads(__tstate);
24330 if (PyErr_Occurred()) SWIG_fail;
24331 }
24332 resultobj = SWIG_Py_Void();
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24340 PyObject *resultobj = 0;
24341 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24342 bool result;
24343 void *argp1 = 0 ;
24344 int res1 = 0 ;
24345 PyObject *swig_obj[1] ;
24346
24347 if (!args) SWIG_fail;
24348 swig_obj[0] = args;
24349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24350 if (!SWIG_IsOK(res1)) {
24351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24352 }
24353 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 {
24361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24362 }
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24370 PyObject *obj;
24371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24372 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24373 return SWIG_Py_Void();
24374 }
24375
24376 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24377 return SWIG_Python_InitShadowInstance(args);
24378 }
24379
24380 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj = 0;
24382 int arg1 = (int) 0 ;
24383 bool arg2 = (bool) false ;
24384 wxShowEvent *result = 0 ;
24385 int val1 ;
24386 int ecode1 = 0 ;
24387 bool val2 ;
24388 int ecode2 = 0 ;
24389 PyObject * obj0 = 0 ;
24390 PyObject * obj1 = 0 ;
24391 char * kwnames[] = {
24392 (char *) "winid",(char *) "show", NULL
24393 };
24394
24395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24396 if (obj0) {
24397 ecode1 = SWIG_AsVal_int(obj0, &val1);
24398 if (!SWIG_IsOK(ecode1)) {
24399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24400 }
24401 arg1 = static_cast< int >(val1);
24402 }
24403 if (obj1) {
24404 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24405 if (!SWIG_IsOK(ecode2)) {
24406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24407 }
24408 arg2 = static_cast< bool >(val2);
24409 }
24410 {
24411 PyThreadState* __tstate = wxPyBeginAllowThreads();
24412 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24424 PyObject *resultobj = 0;
24425 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24426 bool arg2 ;
24427 void *argp1 = 0 ;
24428 int res1 = 0 ;
24429 bool val2 ;
24430 int ecode2 = 0 ;
24431 PyObject * obj0 = 0 ;
24432 PyObject * obj1 = 0 ;
24433 char * kwnames[] = {
24434 (char *) "self",(char *) "show", NULL
24435 };
24436
24437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24439 if (!SWIG_IsOK(res1)) {
24440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24441 }
24442 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24443 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24444 if (!SWIG_IsOK(ecode2)) {
24445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24446 }
24447 arg2 = static_cast< bool >(val2);
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 (arg1)->SetShow(arg2);
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_Py_Void();
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 PyObject *resultobj = 0;
24463 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24464 bool result;
24465 void *argp1 = 0 ;
24466 int res1 = 0 ;
24467 PyObject *swig_obj[1] ;
24468
24469 if (!args) SWIG_fail;
24470 swig_obj[0] = args;
24471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24472 if (!SWIG_IsOK(res1)) {
24473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24474 }
24475 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24476 {
24477 PyThreadState* __tstate = wxPyBeginAllowThreads();
24478 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24492 PyObject *obj;
24493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24494 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24495 return SWIG_Py_Void();
24496 }
24497
24498 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24499 return SWIG_Python_InitShadowInstance(args);
24500 }
24501
24502 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24503 PyObject *resultobj = 0;
24504 int arg1 = (int) 0 ;
24505 bool arg2 = (bool) true ;
24506 wxIconizeEvent *result = 0 ;
24507 int val1 ;
24508 int ecode1 = 0 ;
24509 bool val2 ;
24510 int ecode2 = 0 ;
24511 PyObject * obj0 = 0 ;
24512 PyObject * obj1 = 0 ;
24513 char * kwnames[] = {
24514 (char *) "id",(char *) "iconized", NULL
24515 };
24516
24517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24518 if (obj0) {
24519 ecode1 = SWIG_AsVal_int(obj0, &val1);
24520 if (!SWIG_IsOK(ecode1)) {
24521 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24522 }
24523 arg1 = static_cast< int >(val1);
24524 }
24525 if (obj1) {
24526 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24527 if (!SWIG_IsOK(ecode2)) {
24528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24529 }
24530 arg2 = static_cast< bool >(val2);
24531 }
24532 {
24533 PyThreadState* __tstate = wxPyBeginAllowThreads();
24534 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24535 wxPyEndAllowThreads(__tstate);
24536 if (PyErr_Occurred()) SWIG_fail;
24537 }
24538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24539 return resultobj;
24540 fail:
24541 return NULL;
24542 }
24543
24544
24545 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24546 PyObject *resultobj = 0;
24547 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24548 bool result;
24549 void *argp1 = 0 ;
24550 int res1 = 0 ;
24551 PyObject *swig_obj[1] ;
24552
24553 if (!args) SWIG_fail;
24554 swig_obj[0] = args;
24555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24556 if (!SWIG_IsOK(res1)) {
24557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24558 }
24559 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = (bool)(arg1)->Iconized();
24563 wxPyEndAllowThreads(__tstate);
24564 if (PyErr_Occurred()) SWIG_fail;
24565 }
24566 {
24567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24568 }
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24576 PyObject *obj;
24577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24578 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24579 return SWIG_Py_Void();
24580 }
24581
24582 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24583 return SWIG_Python_InitShadowInstance(args);
24584 }
24585
24586 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24587 PyObject *resultobj = 0;
24588 int arg1 = (int) 0 ;
24589 wxMaximizeEvent *result = 0 ;
24590 int val1 ;
24591 int ecode1 = 0 ;
24592 PyObject * obj0 = 0 ;
24593 char * kwnames[] = {
24594 (char *) "id", NULL
24595 };
24596
24597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24598 if (obj0) {
24599 ecode1 = SWIG_AsVal_int(obj0, &val1);
24600 if (!SWIG_IsOK(ecode1)) {
24601 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24602 }
24603 arg1 = static_cast< int >(val1);
24604 }
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24608 wxPyEndAllowThreads(__tstate);
24609 if (PyErr_Occurred()) SWIG_fail;
24610 }
24611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24619 PyObject *obj;
24620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24621 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24622 return SWIG_Py_Void();
24623 }
24624
24625 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24626 return SWIG_Python_InitShadowInstance(args);
24627 }
24628
24629 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 PyObject *resultobj = 0;
24631 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24632 wxPoint result;
24633 void *argp1 = 0 ;
24634 int res1 = 0 ;
24635 PyObject *swig_obj[1] ;
24636
24637 if (!args) SWIG_fail;
24638 swig_obj[0] = args;
24639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24640 if (!SWIG_IsOK(res1)) {
24641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24642 }
24643 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24644 {
24645 PyThreadState* __tstate = wxPyBeginAllowThreads();
24646 result = (arg1)->GetPosition();
24647 wxPyEndAllowThreads(__tstate);
24648 if (PyErr_Occurred()) SWIG_fail;
24649 }
24650 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24651 return resultobj;
24652 fail:
24653 return NULL;
24654 }
24655
24656
24657 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24658 PyObject *resultobj = 0;
24659 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 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_wxDropFilesEvent, 0 | 0 );
24668 if (!SWIG_IsOK(res1)) {
24669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24670 }
24671 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24672 {
24673 PyThreadState* __tstate = wxPyBeginAllowThreads();
24674 result = (int)(arg1)->GetNumberOfFiles();
24675 wxPyEndAllowThreads(__tstate);
24676 if (PyErr_Occurred()) SWIG_fail;
24677 }
24678 resultobj = SWIG_From_int(static_cast< int >(result));
24679 return resultobj;
24680 fail:
24681 return NULL;
24682 }
24683
24684
24685 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24686 PyObject *resultobj = 0;
24687 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24688 PyObject *result = 0 ;
24689 void *argp1 = 0 ;
24690 int res1 = 0 ;
24691 PyObject *swig_obj[1] ;
24692
24693 if (!args) SWIG_fail;
24694 swig_obj[0] = args;
24695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24696 if (!SWIG_IsOK(res1)) {
24697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24698 }
24699 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24700 {
24701 PyThreadState* __tstate = wxPyBeginAllowThreads();
24702 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 resultobj = result;
24707 return resultobj;
24708 fail:
24709 return NULL;
24710 }
24711
24712
24713 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24714 PyObject *obj;
24715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24716 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24717 return SWIG_Py_Void();
24718 }
24719
24720 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24721 PyObject *resultobj = 0;
24722 int arg1 = (int) 0 ;
24723 wxUpdateUIEvent *result = 0 ;
24724 int val1 ;
24725 int ecode1 = 0 ;
24726 PyObject * obj0 = 0 ;
24727 char * kwnames[] = {
24728 (char *) "commandId", NULL
24729 };
24730
24731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24732 if (obj0) {
24733 ecode1 = SWIG_AsVal_int(obj0, &val1);
24734 if (!SWIG_IsOK(ecode1)) {
24735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24736 }
24737 arg1 = static_cast< int >(val1);
24738 }
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24753 PyObject *resultobj = 0;
24754 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24755 bool result;
24756 void *argp1 = 0 ;
24757 int res1 = 0 ;
24758 PyObject *swig_obj[1] ;
24759
24760 if (!args) SWIG_fail;
24761 swig_obj[0] = args;
24762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24763 if (!SWIG_IsOK(res1)) {
24764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24765 }
24766 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 {
24774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24775 }
24776 return resultobj;
24777 fail:
24778 return NULL;
24779 }
24780
24781
24782 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24783 PyObject *resultobj = 0;
24784 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24785 bool result;
24786 void *argp1 = 0 ;
24787 int res1 = 0 ;
24788 PyObject *swig_obj[1] ;
24789
24790 if (!args) SWIG_fail;
24791 swig_obj[0] = args;
24792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24793 if (!SWIG_IsOK(res1)) {
24794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24795 }
24796 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24797 {
24798 PyThreadState* __tstate = wxPyBeginAllowThreads();
24799 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24800 wxPyEndAllowThreads(__tstate);
24801 if (PyErr_Occurred()) SWIG_fail;
24802 }
24803 {
24804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24805 }
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24813 PyObject *resultobj = 0;
24814 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24815 bool result;
24816 void *argp1 = 0 ;
24817 int res1 = 0 ;
24818 PyObject *swig_obj[1] ;
24819
24820 if (!args) SWIG_fail;
24821 swig_obj[0] = args;
24822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24823 if (!SWIG_IsOK(res1)) {
24824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24825 }
24826 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24830 wxPyEndAllowThreads(__tstate);
24831 if (PyErr_Occurred()) SWIG_fail;
24832 }
24833 {
24834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24835 }
24836 return resultobj;
24837 fail:
24838 return NULL;
24839 }
24840
24841
24842 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24843 PyObject *resultobj = 0;
24844 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24845 wxString result;
24846 void *argp1 = 0 ;
24847 int res1 = 0 ;
24848 PyObject *swig_obj[1] ;
24849
24850 if (!args) SWIG_fail;
24851 swig_obj[0] = args;
24852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24853 if (!SWIG_IsOK(res1)) {
24854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24855 }
24856 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24857 {
24858 PyThreadState* __tstate = wxPyBeginAllowThreads();
24859 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24860 wxPyEndAllowThreads(__tstate);
24861 if (PyErr_Occurred()) SWIG_fail;
24862 }
24863 {
24864 #if wxUSE_UNICODE
24865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24866 #else
24867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24868 #endif
24869 }
24870 return resultobj;
24871 fail:
24872 return NULL;
24873 }
24874
24875
24876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24877 PyObject *resultobj = 0;
24878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24879 bool result;
24880 void *argp1 = 0 ;
24881 int res1 = 0 ;
24882 PyObject *swig_obj[1] ;
24883
24884 if (!args) SWIG_fail;
24885 swig_obj[0] = args;
24886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24887 if (!SWIG_IsOK(res1)) {
24888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24889 }
24890 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 {
24898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24899 }
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24907 PyObject *resultobj = 0;
24908 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24909 bool result;
24910 void *argp1 = 0 ;
24911 int res1 = 0 ;
24912 PyObject *swig_obj[1] ;
24913
24914 if (!args) SWIG_fail;
24915 swig_obj[0] = args;
24916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24917 if (!SWIG_IsOK(res1)) {
24918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24919 }
24920 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24921 {
24922 PyThreadState* __tstate = wxPyBeginAllowThreads();
24923 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24924 wxPyEndAllowThreads(__tstate);
24925 if (PyErr_Occurred()) SWIG_fail;
24926 }
24927 {
24928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24929 }
24930 return resultobj;
24931 fail:
24932 return NULL;
24933 }
24934
24935
24936 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24937 PyObject *resultobj = 0;
24938 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24939 bool result;
24940 void *argp1 = 0 ;
24941 int res1 = 0 ;
24942 PyObject *swig_obj[1] ;
24943
24944 if (!args) SWIG_fail;
24945 swig_obj[0] = args;
24946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24947 if (!SWIG_IsOK(res1)) {
24948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24949 }
24950 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24951 {
24952 PyThreadState* __tstate = wxPyBeginAllowThreads();
24953 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24954 wxPyEndAllowThreads(__tstate);
24955 if (PyErr_Occurred()) SWIG_fail;
24956 }
24957 {
24958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24959 }
24960 return resultobj;
24961 fail:
24962 return NULL;
24963 }
24964
24965
24966 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24967 PyObject *resultobj = 0;
24968 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24969 bool result;
24970 void *argp1 = 0 ;
24971 int res1 = 0 ;
24972 PyObject *swig_obj[1] ;
24973
24974 if (!args) SWIG_fail;
24975 swig_obj[0] = args;
24976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24977 if (!SWIG_IsOK(res1)) {
24978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24979 }
24980 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 {
24988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24989 }
24990 return resultobj;
24991 fail:
24992 return NULL;
24993 }
24994
24995
24996 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24997 PyObject *resultobj = 0;
24998 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24999 bool arg2 ;
25000 void *argp1 = 0 ;
25001 int res1 = 0 ;
25002 bool val2 ;
25003 int ecode2 = 0 ;
25004 PyObject * obj0 = 0 ;
25005 PyObject * obj1 = 0 ;
25006 char * kwnames[] = {
25007 (char *) "self",(char *) "check", NULL
25008 };
25009
25010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25012 if (!SWIG_IsOK(res1)) {
25013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25014 }
25015 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25016 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25017 if (!SWIG_IsOK(ecode2)) {
25018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25019 }
25020 arg2 = static_cast< bool >(val2);
25021 {
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 (arg1)->Check(arg2);
25024 wxPyEndAllowThreads(__tstate);
25025 if (PyErr_Occurred()) SWIG_fail;
25026 }
25027 resultobj = SWIG_Py_Void();
25028 return resultobj;
25029 fail:
25030 return NULL;
25031 }
25032
25033
25034 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25035 PyObject *resultobj = 0;
25036 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25037 bool arg2 ;
25038 void *argp1 = 0 ;
25039 int res1 = 0 ;
25040 bool val2 ;
25041 int ecode2 = 0 ;
25042 PyObject * obj0 = 0 ;
25043 PyObject * obj1 = 0 ;
25044 char * kwnames[] = {
25045 (char *) "self",(char *) "enable", NULL
25046 };
25047
25048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25050 if (!SWIG_IsOK(res1)) {
25051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25052 }
25053 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25054 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25055 if (!SWIG_IsOK(ecode2)) {
25056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25057 }
25058 arg2 = static_cast< bool >(val2);
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 (arg1)->Enable(arg2);
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 resultobj = SWIG_Py_Void();
25066 return resultobj;
25067 fail:
25068 return NULL;
25069 }
25070
25071
25072 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25073 PyObject *resultobj = 0;
25074 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25075 bool arg2 ;
25076 void *argp1 = 0 ;
25077 int res1 = 0 ;
25078 bool val2 ;
25079 int ecode2 = 0 ;
25080 PyObject * obj0 = 0 ;
25081 PyObject * obj1 = 0 ;
25082 char * kwnames[] = {
25083 (char *) "self",(char *) "show", NULL
25084 };
25085
25086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25088 if (!SWIG_IsOK(res1)) {
25089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25090 }
25091 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25092 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25093 if (!SWIG_IsOK(ecode2)) {
25094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25095 }
25096 arg2 = static_cast< bool >(val2);
25097 {
25098 PyThreadState* __tstate = wxPyBeginAllowThreads();
25099 (arg1)->Show(arg2);
25100 wxPyEndAllowThreads(__tstate);
25101 if (PyErr_Occurred()) SWIG_fail;
25102 }
25103 resultobj = SWIG_Py_Void();
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj = 0;
25112 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25113 wxString *arg2 = 0 ;
25114 void *argp1 = 0 ;
25115 int res1 = 0 ;
25116 bool temp2 = false ;
25117 PyObject * obj0 = 0 ;
25118 PyObject * obj1 = 0 ;
25119 char * kwnames[] = {
25120 (char *) "self",(char *) "text", NULL
25121 };
25122
25123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25125 if (!SWIG_IsOK(res1)) {
25126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25127 }
25128 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25129 {
25130 arg2 = wxString_in_helper(obj1);
25131 if (arg2 == NULL) SWIG_fail;
25132 temp2 = true;
25133 }
25134 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 (arg1)->SetText((wxString const &)*arg2);
25137 wxPyEndAllowThreads(__tstate);
25138 if (PyErr_Occurred()) SWIG_fail;
25139 }
25140 resultobj = SWIG_Py_Void();
25141 {
25142 if (temp2)
25143 delete arg2;
25144 }
25145 return resultobj;
25146 fail:
25147 {
25148 if (temp2)
25149 delete arg2;
25150 }
25151 return NULL;
25152 }
25153
25154
25155 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25156 PyObject *resultobj = 0;
25157 long arg1 ;
25158 long val1 ;
25159 int ecode1 = 0 ;
25160 PyObject * obj0 = 0 ;
25161 char * kwnames[] = {
25162 (char *) "updateInterval", NULL
25163 };
25164
25165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25166 ecode1 = SWIG_AsVal_long(obj0, &val1);
25167 if (!SWIG_IsOK(ecode1)) {
25168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25169 }
25170 arg1 = static_cast< long >(val1);
25171 {
25172 PyThreadState* __tstate = wxPyBeginAllowThreads();
25173 wxUpdateUIEvent::SetUpdateInterval(arg1);
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 resultobj = SWIG_Py_Void();
25178 return resultobj;
25179 fail:
25180 return NULL;
25181 }
25182
25183
25184 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25185 PyObject *resultobj = 0;
25186 long result;
25187
25188 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25189 {
25190 PyThreadState* __tstate = wxPyBeginAllowThreads();
25191 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25192 wxPyEndAllowThreads(__tstate);
25193 if (PyErr_Occurred()) SWIG_fail;
25194 }
25195 resultobj = SWIG_From_long(static_cast< long >(result));
25196 return resultobj;
25197 fail:
25198 return NULL;
25199 }
25200
25201
25202 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25203 PyObject *resultobj = 0;
25204 wxWindow *arg1 = (wxWindow *) 0 ;
25205 bool result;
25206 void *argp1 = 0 ;
25207 int res1 = 0 ;
25208 PyObject * obj0 = 0 ;
25209 char * kwnames[] = {
25210 (char *) "win", NULL
25211 };
25212
25213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25215 if (!SWIG_IsOK(res1)) {
25216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25217 }
25218 arg1 = reinterpret_cast< wxWindow * >(argp1);
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 {
25226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25227 }
25228 return resultobj;
25229 fail:
25230 return NULL;
25231 }
25232
25233
25234 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25235 PyObject *resultobj = 0;
25236
25237 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 wxUpdateUIEvent::ResetUpdateTime();
25241 wxPyEndAllowThreads(__tstate);
25242 if (PyErr_Occurred()) SWIG_fail;
25243 }
25244 resultobj = SWIG_Py_Void();
25245 return resultobj;
25246 fail:
25247 return NULL;
25248 }
25249
25250
25251 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj = 0;
25253 wxUpdateUIMode arg1 ;
25254 int val1 ;
25255 int ecode1 = 0 ;
25256 PyObject * obj0 = 0 ;
25257 char * kwnames[] = {
25258 (char *) "mode", NULL
25259 };
25260
25261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25262 ecode1 = SWIG_AsVal_int(obj0, &val1);
25263 if (!SWIG_IsOK(ecode1)) {
25264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25265 }
25266 arg1 = static_cast< wxUpdateUIMode >(val1);
25267 {
25268 PyThreadState* __tstate = wxPyBeginAllowThreads();
25269 wxUpdateUIEvent::SetMode(arg1);
25270 wxPyEndAllowThreads(__tstate);
25271 if (PyErr_Occurred()) SWIG_fail;
25272 }
25273 resultobj = SWIG_Py_Void();
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25281 PyObject *resultobj = 0;
25282 wxUpdateUIMode result;
25283
25284 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25285 {
25286 PyThreadState* __tstate = wxPyBeginAllowThreads();
25287 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25288 wxPyEndAllowThreads(__tstate);
25289 if (PyErr_Occurred()) SWIG_fail;
25290 }
25291 resultobj = SWIG_From_int(static_cast< int >(result));
25292 return resultobj;
25293 fail:
25294 return NULL;
25295 }
25296
25297
25298 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25299 PyObject *obj;
25300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25301 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25302 return SWIG_Py_Void();
25303 }
25304
25305 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25306 return SWIG_Python_InitShadowInstance(args);
25307 }
25308
25309 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25310 PyObject *resultobj = 0;
25311 wxSysColourChangedEvent *result = 0 ;
25312
25313 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25314 {
25315 PyThreadState* __tstate = wxPyBeginAllowThreads();
25316 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25317 wxPyEndAllowThreads(__tstate);
25318 if (PyErr_Occurred()) SWIG_fail;
25319 }
25320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25321 return resultobj;
25322 fail:
25323 return NULL;
25324 }
25325
25326
25327 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25328 PyObject *obj;
25329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25330 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25331 return SWIG_Py_Void();
25332 }
25333
25334 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25335 return SWIG_Python_InitShadowInstance(args);
25336 }
25337
25338 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25339 PyObject *resultobj = 0;
25340 int arg1 = (int) 0 ;
25341 wxWindow *arg2 = (wxWindow *) NULL ;
25342 wxMouseCaptureChangedEvent *result = 0 ;
25343 int val1 ;
25344 int ecode1 = 0 ;
25345 void *argp2 = 0 ;
25346 int res2 = 0 ;
25347 PyObject * obj0 = 0 ;
25348 PyObject * obj1 = 0 ;
25349 char * kwnames[] = {
25350 (char *) "winid",(char *) "gainedCapture", NULL
25351 };
25352
25353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25354 if (obj0) {
25355 ecode1 = SWIG_AsVal_int(obj0, &val1);
25356 if (!SWIG_IsOK(ecode1)) {
25357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25358 }
25359 arg1 = static_cast< int >(val1);
25360 }
25361 if (obj1) {
25362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25363 if (!SWIG_IsOK(res2)) {
25364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25365 }
25366 arg2 = reinterpret_cast< wxWindow * >(argp2);
25367 }
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25382 PyObject *resultobj = 0;
25383 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25384 wxWindow *result = 0 ;
25385 void *argp1 = 0 ;
25386 int res1 = 0 ;
25387 PyObject *swig_obj[1] ;
25388
25389 if (!args) SWIG_fail;
25390 swig_obj[0] = args;
25391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25392 if (!SWIG_IsOK(res1)) {
25393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25394 }
25395 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25396 {
25397 PyThreadState* __tstate = wxPyBeginAllowThreads();
25398 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25399 wxPyEndAllowThreads(__tstate);
25400 if (PyErr_Occurred()) SWIG_fail;
25401 }
25402 {
25403 resultobj = wxPyMake_wxObject(result, (bool)0);
25404 }
25405 return resultobj;
25406 fail:
25407 return NULL;
25408 }
25409
25410
25411 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25412 PyObject *obj;
25413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25414 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25415 return SWIG_Py_Void();
25416 }
25417
25418 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 return SWIG_Python_InitShadowInstance(args);
25420 }
25421
25422 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25423 PyObject *resultobj = 0;
25424 wxDisplayChangedEvent *result = 0 ;
25425
25426 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25427 {
25428 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25430 wxPyEndAllowThreads(__tstate);
25431 if (PyErr_Occurred()) SWIG_fail;
25432 }
25433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25434 return resultobj;
25435 fail:
25436 return NULL;
25437 }
25438
25439
25440 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25441 PyObject *obj;
25442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25443 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25444 return SWIG_Py_Void();
25445 }
25446
25447 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25448 return SWIG_Python_InitShadowInstance(args);
25449 }
25450
25451 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25452 PyObject *resultobj = 0;
25453 int arg1 = (int) 0 ;
25454 wxPaletteChangedEvent *result = 0 ;
25455 int val1 ;
25456 int ecode1 = 0 ;
25457 PyObject * obj0 = 0 ;
25458 char * kwnames[] = {
25459 (char *) "id", NULL
25460 };
25461
25462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25463 if (obj0) {
25464 ecode1 = SWIG_AsVal_int(obj0, &val1);
25465 if (!SWIG_IsOK(ecode1)) {
25466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25467 }
25468 arg1 = static_cast< int >(val1);
25469 }
25470 {
25471 PyThreadState* __tstate = wxPyBeginAllowThreads();
25472 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25473 wxPyEndAllowThreads(__tstate);
25474 if (PyErr_Occurred()) SWIG_fail;
25475 }
25476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25477 return resultobj;
25478 fail:
25479 return NULL;
25480 }
25481
25482
25483 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25484 PyObject *resultobj = 0;
25485 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25486 wxWindow *arg2 = (wxWindow *) 0 ;
25487 void *argp1 = 0 ;
25488 int res1 = 0 ;
25489 void *argp2 = 0 ;
25490 int res2 = 0 ;
25491 PyObject * obj0 = 0 ;
25492 PyObject * obj1 = 0 ;
25493 char * kwnames[] = {
25494 (char *) "self",(char *) "win", NULL
25495 };
25496
25497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25499 if (!SWIG_IsOK(res1)) {
25500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25501 }
25502 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25503 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25504 if (!SWIG_IsOK(res2)) {
25505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25506 }
25507 arg2 = reinterpret_cast< wxWindow * >(argp2);
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 (arg1)->SetChangedWindow(arg2);
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 resultobj = SWIG_Py_Void();
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25522 PyObject *resultobj = 0;
25523 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25524 wxWindow *result = 0 ;
25525 void *argp1 = 0 ;
25526 int res1 = 0 ;
25527 PyObject *swig_obj[1] ;
25528
25529 if (!args) SWIG_fail;
25530 swig_obj[0] = args;
25531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25532 if (!SWIG_IsOK(res1)) {
25533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25534 }
25535 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25536 {
25537 PyThreadState* __tstate = wxPyBeginAllowThreads();
25538 result = (wxWindow *)(arg1)->GetChangedWindow();
25539 wxPyEndAllowThreads(__tstate);
25540 if (PyErr_Occurred()) SWIG_fail;
25541 }
25542 {
25543 resultobj = wxPyMake_wxObject(result, (bool)0);
25544 }
25545 return resultobj;
25546 fail:
25547 return NULL;
25548 }
25549
25550
25551 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25552 PyObject *obj;
25553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25554 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25555 return SWIG_Py_Void();
25556 }
25557
25558 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25559 return SWIG_Python_InitShadowInstance(args);
25560 }
25561
25562 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25563 PyObject *resultobj = 0;
25564 int arg1 = (int) 0 ;
25565 wxQueryNewPaletteEvent *result = 0 ;
25566 int val1 ;
25567 int ecode1 = 0 ;
25568 PyObject * obj0 = 0 ;
25569 char * kwnames[] = {
25570 (char *) "winid", NULL
25571 };
25572
25573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25574 if (obj0) {
25575 ecode1 = SWIG_AsVal_int(obj0, &val1);
25576 if (!SWIG_IsOK(ecode1)) {
25577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25578 }
25579 arg1 = static_cast< int >(val1);
25580 }
25581 {
25582 PyThreadState* __tstate = wxPyBeginAllowThreads();
25583 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25584 wxPyEndAllowThreads(__tstate);
25585 if (PyErr_Occurred()) SWIG_fail;
25586 }
25587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25588 return resultobj;
25589 fail:
25590 return NULL;
25591 }
25592
25593
25594 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25595 PyObject *resultobj = 0;
25596 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25597 bool arg2 ;
25598 void *argp1 = 0 ;
25599 int res1 = 0 ;
25600 bool val2 ;
25601 int ecode2 = 0 ;
25602 PyObject * obj0 = 0 ;
25603 PyObject * obj1 = 0 ;
25604 char * kwnames[] = {
25605 (char *) "self",(char *) "realized", NULL
25606 };
25607
25608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25610 if (!SWIG_IsOK(res1)) {
25611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25612 }
25613 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25614 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25615 if (!SWIG_IsOK(ecode2)) {
25616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25617 }
25618 arg2 = static_cast< bool >(val2);
25619 {
25620 PyThreadState* __tstate = wxPyBeginAllowThreads();
25621 (arg1)->SetPaletteRealized(arg2);
25622 wxPyEndAllowThreads(__tstate);
25623 if (PyErr_Occurred()) SWIG_fail;
25624 }
25625 resultobj = SWIG_Py_Void();
25626 return resultobj;
25627 fail:
25628 return NULL;
25629 }
25630
25631
25632 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25633 PyObject *resultobj = 0;
25634 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25635 bool result;
25636 void *argp1 = 0 ;
25637 int res1 = 0 ;
25638 PyObject *swig_obj[1] ;
25639
25640 if (!args) SWIG_fail;
25641 swig_obj[0] = args;
25642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25643 if (!SWIG_IsOK(res1)) {
25644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25645 }
25646 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25647 {
25648 PyThreadState* __tstate = wxPyBeginAllowThreads();
25649 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25650 wxPyEndAllowThreads(__tstate);
25651 if (PyErr_Occurred()) SWIG_fail;
25652 }
25653 {
25654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25655 }
25656 return resultobj;
25657 fail:
25658 return NULL;
25659 }
25660
25661
25662 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25663 PyObject *obj;
25664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25665 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25666 return SWIG_Py_Void();
25667 }
25668
25669 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25670 return SWIG_Python_InitShadowInstance(args);
25671 }
25672
25673 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxNavigationKeyEvent *result = 0 ;
25676
25677 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25678 {
25679 PyThreadState* __tstate = wxPyBeginAllowThreads();
25680 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25681 wxPyEndAllowThreads(__tstate);
25682 if (PyErr_Occurred()) SWIG_fail;
25683 }
25684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25685 return resultobj;
25686 fail:
25687 return NULL;
25688 }
25689
25690
25691 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25692 PyObject *resultobj = 0;
25693 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25694 bool result;
25695 void *argp1 = 0 ;
25696 int res1 = 0 ;
25697 PyObject *swig_obj[1] ;
25698
25699 if (!args) SWIG_fail;
25700 swig_obj[0] = args;
25701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25702 if (!SWIG_IsOK(res1)) {
25703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25704 }
25705 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25706 {
25707 PyThreadState* __tstate = wxPyBeginAllowThreads();
25708 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25709 wxPyEndAllowThreads(__tstate);
25710 if (PyErr_Occurred()) SWIG_fail;
25711 }
25712 {
25713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25714 }
25715 return resultobj;
25716 fail:
25717 return NULL;
25718 }
25719
25720
25721 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25722 PyObject *resultobj = 0;
25723 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25724 bool arg2 ;
25725 void *argp1 = 0 ;
25726 int res1 = 0 ;
25727 bool val2 ;
25728 int ecode2 = 0 ;
25729 PyObject * obj0 = 0 ;
25730 PyObject * obj1 = 0 ;
25731 char * kwnames[] = {
25732 (char *) "self",(char *) "forward", NULL
25733 };
25734
25735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25737 if (!SWIG_IsOK(res1)) {
25738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25739 }
25740 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25741 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25742 if (!SWIG_IsOK(ecode2)) {
25743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25744 }
25745 arg2 = static_cast< bool >(val2);
25746 {
25747 PyThreadState* __tstate = wxPyBeginAllowThreads();
25748 (arg1)->SetDirection(arg2);
25749 wxPyEndAllowThreads(__tstate);
25750 if (PyErr_Occurred()) SWIG_fail;
25751 }
25752 resultobj = SWIG_Py_Void();
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25760 PyObject *resultobj = 0;
25761 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25762 bool result;
25763 void *argp1 = 0 ;
25764 int res1 = 0 ;
25765 PyObject *swig_obj[1] ;
25766
25767 if (!args) SWIG_fail;
25768 swig_obj[0] = args;
25769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25770 if (!SWIG_IsOK(res1)) {
25771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25772 }
25773 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25774 {
25775 PyThreadState* __tstate = wxPyBeginAllowThreads();
25776 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25777 wxPyEndAllowThreads(__tstate);
25778 if (PyErr_Occurred()) SWIG_fail;
25779 }
25780 {
25781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25782 }
25783 return resultobj;
25784 fail:
25785 return NULL;
25786 }
25787
25788
25789 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25790 PyObject *resultobj = 0;
25791 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25792 bool arg2 ;
25793 void *argp1 = 0 ;
25794 int res1 = 0 ;
25795 bool val2 ;
25796 int ecode2 = 0 ;
25797 PyObject * obj0 = 0 ;
25798 PyObject * obj1 = 0 ;
25799 char * kwnames[] = {
25800 (char *) "self",(char *) "ischange", NULL
25801 };
25802
25803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25805 if (!SWIG_IsOK(res1)) {
25806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25807 }
25808 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25810 if (!SWIG_IsOK(ecode2)) {
25811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25812 }
25813 arg2 = static_cast< bool >(val2);
25814 {
25815 PyThreadState* __tstate = wxPyBeginAllowThreads();
25816 (arg1)->SetWindowChange(arg2);
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 resultobj = SWIG_Py_Void();
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25828 PyObject *resultobj = 0;
25829 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25830 bool result;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 PyObject *swig_obj[1] ;
25834
25835 if (!args) SWIG_fail;
25836 swig_obj[0] = args;
25837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25838 if (!SWIG_IsOK(res1)) {
25839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25840 }
25841 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25842 {
25843 PyThreadState* __tstate = wxPyBeginAllowThreads();
25844 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 {
25849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25850 }
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj = 0;
25859 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25860 bool arg2 ;
25861 void *argp1 = 0 ;
25862 int res1 = 0 ;
25863 bool val2 ;
25864 int ecode2 = 0 ;
25865 PyObject * obj0 = 0 ;
25866 PyObject * obj1 = 0 ;
25867 char * kwnames[] = {
25868 (char *) "self",(char *) "bIs", NULL
25869 };
25870
25871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25873 if (!SWIG_IsOK(res1)) {
25874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25875 }
25876 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25878 if (!SWIG_IsOK(ecode2)) {
25879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25880 }
25881 arg2 = static_cast< bool >(val2);
25882 {
25883 PyThreadState* __tstate = wxPyBeginAllowThreads();
25884 (arg1)->SetFromTab(arg2);
25885 wxPyEndAllowThreads(__tstate);
25886 if (PyErr_Occurred()) SWIG_fail;
25887 }
25888 resultobj = SWIG_Py_Void();
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj = 0;
25897 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25898 long arg2 ;
25899 void *argp1 = 0 ;
25900 int res1 = 0 ;
25901 long val2 ;
25902 int ecode2 = 0 ;
25903 PyObject * obj0 = 0 ;
25904 PyObject * obj1 = 0 ;
25905 char * kwnames[] = {
25906 (char *) "self",(char *) "flags", NULL
25907 };
25908
25909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25911 if (!SWIG_IsOK(res1)) {
25912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25913 }
25914 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25915 ecode2 = SWIG_AsVal_long(obj1, &val2);
25916 if (!SWIG_IsOK(ecode2)) {
25917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25918 }
25919 arg2 = static_cast< long >(val2);
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 (arg1)->SetFlags(arg2);
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 resultobj = SWIG_Py_Void();
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25934 PyObject *resultobj = 0;
25935 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25936 wxWindow *result = 0 ;
25937 void *argp1 = 0 ;
25938 int res1 = 0 ;
25939 PyObject *swig_obj[1] ;
25940
25941 if (!args) SWIG_fail;
25942 swig_obj[0] = args;
25943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25944 if (!SWIG_IsOK(res1)) {
25945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25946 }
25947 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25948 {
25949 PyThreadState* __tstate = wxPyBeginAllowThreads();
25950 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 {
25955 resultobj = wxPyMake_wxObject(result, (bool)0);
25956 }
25957 return resultobj;
25958 fail:
25959 return NULL;
25960 }
25961
25962
25963 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25964 PyObject *resultobj = 0;
25965 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25966 wxWindow *arg2 = (wxWindow *) 0 ;
25967 void *argp1 = 0 ;
25968 int res1 = 0 ;
25969 void *argp2 = 0 ;
25970 int res2 = 0 ;
25971 PyObject * obj0 = 0 ;
25972 PyObject * obj1 = 0 ;
25973 char * kwnames[] = {
25974 (char *) "self",(char *) "win", NULL
25975 };
25976
25977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25979 if (!SWIG_IsOK(res1)) {
25980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25981 }
25982 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25984 if (!SWIG_IsOK(res2)) {
25985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25986 }
25987 arg2 = reinterpret_cast< wxWindow * >(argp2);
25988 {
25989 PyThreadState* __tstate = wxPyBeginAllowThreads();
25990 (arg1)->SetCurrentFocus(arg2);
25991 wxPyEndAllowThreads(__tstate);
25992 if (PyErr_Occurred()) SWIG_fail;
25993 }
25994 resultobj = SWIG_Py_Void();
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26002 PyObject *obj;
26003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26004 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26005 return SWIG_Py_Void();
26006 }
26007
26008 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26009 return SWIG_Python_InitShadowInstance(args);
26010 }
26011
26012 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26013 PyObject *resultobj = 0;
26014 wxWindow *arg1 = (wxWindow *) NULL ;
26015 wxWindowCreateEvent *result = 0 ;
26016 void *argp1 = 0 ;
26017 int res1 = 0 ;
26018 PyObject * obj0 = 0 ;
26019 char * kwnames[] = {
26020 (char *) "win", NULL
26021 };
26022
26023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26024 if (obj0) {
26025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26026 if (!SWIG_IsOK(res1)) {
26027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26028 }
26029 arg1 = reinterpret_cast< wxWindow * >(argp1);
26030 }
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26045 PyObject *resultobj = 0;
26046 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26047 wxWindow *result = 0 ;
26048 void *argp1 = 0 ;
26049 int res1 = 0 ;
26050 PyObject *swig_obj[1] ;
26051
26052 if (!args) SWIG_fail;
26053 swig_obj[0] = args;
26054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26055 if (!SWIG_IsOK(res1)) {
26056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26057 }
26058 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26059 {
26060 PyThreadState* __tstate = wxPyBeginAllowThreads();
26061 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 {
26066 resultobj = wxPyMake_wxObject(result, (bool)0);
26067 }
26068 return resultobj;
26069 fail:
26070 return NULL;
26071 }
26072
26073
26074 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26075 PyObject *obj;
26076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26077 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26078 return SWIG_Py_Void();
26079 }
26080
26081 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26082 return SWIG_Python_InitShadowInstance(args);
26083 }
26084
26085 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26086 PyObject *resultobj = 0;
26087 wxWindow *arg1 = (wxWindow *) NULL ;
26088 wxWindowDestroyEvent *result = 0 ;
26089 void *argp1 = 0 ;
26090 int res1 = 0 ;
26091 PyObject * obj0 = 0 ;
26092 char * kwnames[] = {
26093 (char *) "win", NULL
26094 };
26095
26096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26097 if (obj0) {
26098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26099 if (!SWIG_IsOK(res1)) {
26100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26101 }
26102 arg1 = reinterpret_cast< wxWindow * >(argp1);
26103 }
26104 {
26105 PyThreadState* __tstate = wxPyBeginAllowThreads();
26106 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26107 wxPyEndAllowThreads(__tstate);
26108 if (PyErr_Occurred()) SWIG_fail;
26109 }
26110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26111 return resultobj;
26112 fail:
26113 return NULL;
26114 }
26115
26116
26117 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26118 PyObject *resultobj = 0;
26119 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26120 wxWindow *result = 0 ;
26121 void *argp1 = 0 ;
26122 int res1 = 0 ;
26123 PyObject *swig_obj[1] ;
26124
26125 if (!args) SWIG_fail;
26126 swig_obj[0] = args;
26127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26128 if (!SWIG_IsOK(res1)) {
26129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26130 }
26131 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 {
26139 resultobj = wxPyMake_wxObject(result, (bool)0);
26140 }
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26148 PyObject *obj;
26149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26150 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26151 return SWIG_Py_Void();
26152 }
26153
26154 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26155 return SWIG_Python_InitShadowInstance(args);
26156 }
26157
26158 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26159 PyObject *resultobj = 0;
26160 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26161 int arg2 = (int) 0 ;
26162 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26163 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26164 wxContextMenuEvent *result = 0 ;
26165 int val1 ;
26166 int ecode1 = 0 ;
26167 int val2 ;
26168 int ecode2 = 0 ;
26169 wxPoint temp3 ;
26170 PyObject * obj0 = 0 ;
26171 PyObject * obj1 = 0 ;
26172 PyObject * obj2 = 0 ;
26173 char * kwnames[] = {
26174 (char *) "type",(char *) "winid",(char *) "pt", NULL
26175 };
26176
26177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26178 if (obj0) {
26179 ecode1 = SWIG_AsVal_int(obj0, &val1);
26180 if (!SWIG_IsOK(ecode1)) {
26181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26182 }
26183 arg1 = static_cast< wxEventType >(val1);
26184 }
26185 if (obj1) {
26186 ecode2 = SWIG_AsVal_int(obj1, &val2);
26187 if (!SWIG_IsOK(ecode2)) {
26188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26189 }
26190 arg2 = static_cast< int >(val2);
26191 }
26192 if (obj2) {
26193 {
26194 arg3 = &temp3;
26195 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26196 }
26197 }
26198 {
26199 PyThreadState* __tstate = wxPyBeginAllowThreads();
26200 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26201 wxPyEndAllowThreads(__tstate);
26202 if (PyErr_Occurred()) SWIG_fail;
26203 }
26204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26205 return resultobj;
26206 fail:
26207 return NULL;
26208 }
26209
26210
26211 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26212 PyObject *resultobj = 0;
26213 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26214 wxPoint *result = 0 ;
26215 void *argp1 = 0 ;
26216 int res1 = 0 ;
26217 PyObject *swig_obj[1] ;
26218
26219 if (!args) SWIG_fail;
26220 swig_obj[0] = args;
26221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26222 if (!SWIG_IsOK(res1)) {
26223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26224 }
26225 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26226 {
26227 PyThreadState* __tstate = wxPyBeginAllowThreads();
26228 {
26229 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26230 result = (wxPoint *) &_result_ref;
26231 }
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26243 PyObject *resultobj = 0;
26244 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26245 wxPoint *arg2 = 0 ;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 wxPoint temp2 ;
26249 PyObject * obj0 = 0 ;
26250 PyObject * obj1 = 0 ;
26251 char * kwnames[] = {
26252 (char *) "self",(char *) "pos", NULL
26253 };
26254
26255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26257 if (!SWIG_IsOK(res1)) {
26258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26259 }
26260 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26261 {
26262 arg2 = &temp2;
26263 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26264 }
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 (arg1)->SetPosition((wxPoint const &)*arg2);
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 resultobj = SWIG_Py_Void();
26272 return resultobj;
26273 fail:
26274 return NULL;
26275 }
26276
26277
26278 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26279 PyObject *obj;
26280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26281 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26282 return SWIG_Py_Void();
26283 }
26284
26285 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26286 return SWIG_Python_InitShadowInstance(args);
26287 }
26288
26289 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 PyObject *resultobj = 0;
26291 wxIdleEvent *result = 0 ;
26292
26293 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 result = (wxIdleEvent *)new wxIdleEvent();
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26301 return resultobj;
26302 fail:
26303 return NULL;
26304 }
26305
26306
26307 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj = 0;
26309 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26310 bool arg2 = (bool) true ;
26311 void *argp1 = 0 ;
26312 int res1 = 0 ;
26313 bool val2 ;
26314 int ecode2 = 0 ;
26315 PyObject * obj0 = 0 ;
26316 PyObject * obj1 = 0 ;
26317 char * kwnames[] = {
26318 (char *) "self",(char *) "needMore", NULL
26319 };
26320
26321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26323 if (!SWIG_IsOK(res1)) {
26324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26325 }
26326 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26327 if (obj1) {
26328 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26329 if (!SWIG_IsOK(ecode2)) {
26330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26331 }
26332 arg2 = static_cast< bool >(val2);
26333 }
26334 {
26335 PyThreadState* __tstate = wxPyBeginAllowThreads();
26336 (arg1)->RequestMore(arg2);
26337 wxPyEndAllowThreads(__tstate);
26338 if (PyErr_Occurred()) SWIG_fail;
26339 }
26340 resultobj = SWIG_Py_Void();
26341 return resultobj;
26342 fail:
26343 return NULL;
26344 }
26345
26346
26347 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26348 PyObject *resultobj = 0;
26349 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26350 bool result;
26351 void *argp1 = 0 ;
26352 int res1 = 0 ;
26353 PyObject *swig_obj[1] ;
26354
26355 if (!args) SWIG_fail;
26356 swig_obj[0] = args;
26357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26360 }
26361 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26362 {
26363 PyThreadState* __tstate = wxPyBeginAllowThreads();
26364 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26365 wxPyEndAllowThreads(__tstate);
26366 if (PyErr_Occurred()) SWIG_fail;
26367 }
26368 {
26369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26370 }
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26378 PyObject *resultobj = 0;
26379 wxIdleMode arg1 ;
26380 int val1 ;
26381 int ecode1 = 0 ;
26382 PyObject * obj0 = 0 ;
26383 char * kwnames[] = {
26384 (char *) "mode", NULL
26385 };
26386
26387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26388 ecode1 = SWIG_AsVal_int(obj0, &val1);
26389 if (!SWIG_IsOK(ecode1)) {
26390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26391 }
26392 arg1 = static_cast< wxIdleMode >(val1);
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 wxIdleEvent::SetMode(arg1);
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_Py_Void();
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26407 PyObject *resultobj = 0;
26408 wxIdleMode result;
26409
26410 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26411 {
26412 PyThreadState* __tstate = wxPyBeginAllowThreads();
26413 result = (wxIdleMode)wxIdleEvent::GetMode();
26414 wxPyEndAllowThreads(__tstate);
26415 if (PyErr_Occurred()) SWIG_fail;
26416 }
26417 resultobj = SWIG_From_int(static_cast< int >(result));
26418 return resultobj;
26419 fail:
26420 return NULL;
26421 }
26422
26423
26424 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26425 PyObject *resultobj = 0;
26426 wxWindow *arg1 = (wxWindow *) 0 ;
26427 bool result;
26428 void *argp1 = 0 ;
26429 int res1 = 0 ;
26430 PyObject * obj0 = 0 ;
26431 char * kwnames[] = {
26432 (char *) "win", NULL
26433 };
26434
26435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26437 if (!SWIG_IsOK(res1)) {
26438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26439 }
26440 arg1 = reinterpret_cast< wxWindow * >(argp1);
26441 {
26442 PyThreadState* __tstate = wxPyBeginAllowThreads();
26443 result = (bool)wxIdleEvent::CanSend(arg1);
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 {
26448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26449 }
26450 return resultobj;
26451 fail:
26452 return NULL;
26453 }
26454
26455
26456 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26457 PyObject *obj;
26458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26459 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26460 return SWIG_Py_Void();
26461 }
26462
26463 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26464 return SWIG_Python_InitShadowInstance(args);
26465 }
26466
26467 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26468 PyObject *resultobj = 0;
26469 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26470 int arg2 = (int) 0 ;
26471 wxClipboardTextEvent *result = 0 ;
26472 int val1 ;
26473 int ecode1 = 0 ;
26474 int val2 ;
26475 int ecode2 = 0 ;
26476 PyObject * obj0 = 0 ;
26477 PyObject * obj1 = 0 ;
26478 char * kwnames[] = {
26479 (char *) "type",(char *) "winid", NULL
26480 };
26481
26482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26483 if (obj0) {
26484 ecode1 = SWIG_AsVal_int(obj0, &val1);
26485 if (!SWIG_IsOK(ecode1)) {
26486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26487 }
26488 arg1 = static_cast< wxEventType >(val1);
26489 }
26490 if (obj1) {
26491 ecode2 = SWIG_AsVal_int(obj1, &val2);
26492 if (!SWIG_IsOK(ecode2)) {
26493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26494 }
26495 arg2 = static_cast< int >(val2);
26496 }
26497 {
26498 PyThreadState* __tstate = wxPyBeginAllowThreads();
26499 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26500 wxPyEndAllowThreads(__tstate);
26501 if (PyErr_Occurred()) SWIG_fail;
26502 }
26503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26504 return resultobj;
26505 fail:
26506 return NULL;
26507 }
26508
26509
26510 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26511 PyObject *obj;
26512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26513 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26514 return SWIG_Py_Void();
26515 }
26516
26517 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26518 return SWIG_Python_InitShadowInstance(args);
26519 }
26520
26521 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26522 PyObject *resultobj = 0;
26523 int arg1 = (int) 0 ;
26524 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26525 wxPyEvent *result = 0 ;
26526 int val1 ;
26527 int ecode1 = 0 ;
26528 int val2 ;
26529 int ecode2 = 0 ;
26530 PyObject * obj0 = 0 ;
26531 PyObject * obj1 = 0 ;
26532 char * kwnames[] = {
26533 (char *) "winid",(char *) "eventType", NULL
26534 };
26535
26536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26537 if (obj0) {
26538 ecode1 = SWIG_AsVal_int(obj0, &val1);
26539 if (!SWIG_IsOK(ecode1)) {
26540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26541 }
26542 arg1 = static_cast< int >(val1);
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_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26548 }
26549 arg2 = static_cast< wxEventType >(val2);
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *resultobj = 0;
26566 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26567 void *argp1 = 0 ;
26568 int res1 = 0 ;
26569 PyObject *swig_obj[1] ;
26570
26571 if (!args) SWIG_fail;
26572 swig_obj[0] = args;
26573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26574 if (!SWIG_IsOK(res1)) {
26575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26576 }
26577 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26578 {
26579 PyThreadState* __tstate = wxPyBeginAllowThreads();
26580 delete arg1;
26581
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 resultobj = SWIG_Py_Void();
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26593 PyObject *resultobj = 0;
26594 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26595 PyObject *arg2 = (PyObject *) 0 ;
26596 void *argp1 = 0 ;
26597 int res1 = 0 ;
26598 PyObject * obj0 = 0 ;
26599 PyObject * obj1 = 0 ;
26600 char * kwnames[] = {
26601 (char *) "self",(char *) "self", NULL
26602 };
26603
26604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26606 if (!SWIG_IsOK(res1)) {
26607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26608 }
26609 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26610 arg2 = obj1;
26611 {
26612 PyThreadState* __tstate = wxPyBeginAllowThreads();
26613 (arg1)->SetSelf(arg2);
26614 wxPyEndAllowThreads(__tstate);
26615 if (PyErr_Occurred()) SWIG_fail;
26616 }
26617 resultobj = SWIG_Py_Void();
26618 return resultobj;
26619 fail:
26620 return NULL;
26621 }
26622
26623
26624 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26625 PyObject *resultobj = 0;
26626 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26627 PyObject *result = 0 ;
26628 void *argp1 = 0 ;
26629 int res1 = 0 ;
26630 PyObject *swig_obj[1] ;
26631
26632 if (!args) SWIG_fail;
26633 swig_obj[0] = args;
26634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26635 if (!SWIG_IsOK(res1)) {
26636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26637 }
26638 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 result = (PyObject *)(arg1)->GetSelf();
26642 wxPyEndAllowThreads(__tstate);
26643 if (PyErr_Occurred()) SWIG_fail;
26644 }
26645 resultobj = result;
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26653 PyObject *obj;
26654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26655 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26656 return SWIG_Py_Void();
26657 }
26658
26659 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26660 return SWIG_Python_InitShadowInstance(args);
26661 }
26662
26663 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26664 PyObject *resultobj = 0;
26665 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26666 int arg2 = (int) 0 ;
26667 wxPyCommandEvent *result = 0 ;
26668 int val1 ;
26669 int ecode1 = 0 ;
26670 int val2 ;
26671 int ecode2 = 0 ;
26672 PyObject * obj0 = 0 ;
26673 PyObject * obj1 = 0 ;
26674 char * kwnames[] = {
26675 (char *) "eventType",(char *) "id", NULL
26676 };
26677
26678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26679 if (obj0) {
26680 ecode1 = SWIG_AsVal_int(obj0, &val1);
26681 if (!SWIG_IsOK(ecode1)) {
26682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26683 }
26684 arg1 = static_cast< wxEventType >(val1);
26685 }
26686 if (obj1) {
26687 ecode2 = SWIG_AsVal_int(obj1, &val2);
26688 if (!SWIG_IsOK(ecode2)) {
26689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26690 }
26691 arg2 = static_cast< int >(val2);
26692 }
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26700 return resultobj;
26701 fail:
26702 return NULL;
26703 }
26704
26705
26706 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26707 PyObject *resultobj = 0;
26708 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26709 void *argp1 = 0 ;
26710 int res1 = 0 ;
26711 PyObject *swig_obj[1] ;
26712
26713 if (!args) SWIG_fail;
26714 swig_obj[0] = args;
26715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26716 if (!SWIG_IsOK(res1)) {
26717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26718 }
26719 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26720 {
26721 PyThreadState* __tstate = wxPyBeginAllowThreads();
26722 delete arg1;
26723
26724 wxPyEndAllowThreads(__tstate);
26725 if (PyErr_Occurred()) SWIG_fail;
26726 }
26727 resultobj = SWIG_Py_Void();
26728 return resultobj;
26729 fail:
26730 return NULL;
26731 }
26732
26733
26734 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26735 PyObject *resultobj = 0;
26736 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26737 PyObject *arg2 = (PyObject *) 0 ;
26738 void *argp1 = 0 ;
26739 int res1 = 0 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char * kwnames[] = {
26743 (char *) "self",(char *) "self", NULL
26744 };
26745
26746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26748 if (!SWIG_IsOK(res1)) {
26749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26750 }
26751 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26752 arg2 = obj1;
26753 {
26754 PyThreadState* __tstate = wxPyBeginAllowThreads();
26755 (arg1)->SetSelf(arg2);
26756 wxPyEndAllowThreads(__tstate);
26757 if (PyErr_Occurred()) SWIG_fail;
26758 }
26759 resultobj = SWIG_Py_Void();
26760 return resultobj;
26761 fail:
26762 return NULL;
26763 }
26764
26765
26766 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26767 PyObject *resultobj = 0;
26768 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26769 PyObject *result = 0 ;
26770 void *argp1 = 0 ;
26771 int res1 = 0 ;
26772 PyObject *swig_obj[1] ;
26773
26774 if (!args) SWIG_fail;
26775 swig_obj[0] = args;
26776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26777 if (!SWIG_IsOK(res1)) {
26778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26779 }
26780 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26781 {
26782 PyThreadState* __tstate = wxPyBeginAllowThreads();
26783 result = (PyObject *)(arg1)->GetSelf();
26784 wxPyEndAllowThreads(__tstate);
26785 if (PyErr_Occurred()) SWIG_fail;
26786 }
26787 resultobj = result;
26788 return resultobj;
26789 fail:
26790 return NULL;
26791 }
26792
26793
26794 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26795 PyObject *obj;
26796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26797 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26798 return SWIG_Py_Void();
26799 }
26800
26801 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26802 return SWIG_Python_InitShadowInstance(args);
26803 }
26804
26805 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26806 PyObject *resultobj = 0;
26807 wxWindow *arg1 = (wxWindow *) 0 ;
26808 wxDateTime *arg2 = 0 ;
26809 wxEventType arg3 ;
26810 wxDateEvent *result = 0 ;
26811 void *argp1 = 0 ;
26812 int res1 = 0 ;
26813 void *argp2 = 0 ;
26814 int res2 = 0 ;
26815 int val3 ;
26816 int ecode3 = 0 ;
26817 PyObject * obj0 = 0 ;
26818 PyObject * obj1 = 0 ;
26819 PyObject * obj2 = 0 ;
26820 char * kwnames[] = {
26821 (char *) "win",(char *) "dt",(char *) "type", NULL
26822 };
26823
26824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26826 if (!SWIG_IsOK(res1)) {
26827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26828 }
26829 arg1 = reinterpret_cast< wxWindow * >(argp1);
26830 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26831 if (!SWIG_IsOK(res2)) {
26832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26833 }
26834 if (!argp2) {
26835 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26836 }
26837 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26838 ecode3 = SWIG_AsVal_int(obj2, &val3);
26839 if (!SWIG_IsOK(ecode3)) {
26840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26841 }
26842 arg3 = static_cast< wxEventType >(val3);
26843 {
26844 PyThreadState* __tstate = wxPyBeginAllowThreads();
26845 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26846 wxPyEndAllowThreads(__tstate);
26847 if (PyErr_Occurred()) SWIG_fail;
26848 }
26849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26850 return resultobj;
26851 fail:
26852 return NULL;
26853 }
26854
26855
26856 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26857 PyObject *resultobj = 0;
26858 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26859 wxDateTime *result = 0 ;
26860 void *argp1 = 0 ;
26861 int res1 = 0 ;
26862 PyObject *swig_obj[1] ;
26863
26864 if (!args) SWIG_fail;
26865 swig_obj[0] = args;
26866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26867 if (!SWIG_IsOK(res1)) {
26868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26869 }
26870 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26871 {
26872 PyThreadState* __tstate = wxPyBeginAllowThreads();
26873 {
26874 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26875 result = (wxDateTime *) &_result_ref;
26876 }
26877 wxPyEndAllowThreads(__tstate);
26878 if (PyErr_Occurred()) SWIG_fail;
26879 }
26880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj = 0;
26889 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26890 wxDateTime *arg2 = 0 ;
26891 void *argp1 = 0 ;
26892 int res1 = 0 ;
26893 void *argp2 = 0 ;
26894 int res2 = 0 ;
26895 PyObject * obj0 = 0 ;
26896 PyObject * obj1 = 0 ;
26897 char * kwnames[] = {
26898 (char *) "self",(char *) "date", NULL
26899 };
26900
26901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26903 if (!SWIG_IsOK(res1)) {
26904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26905 }
26906 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26907 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26908 if (!SWIG_IsOK(res2)) {
26909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26910 }
26911 if (!argp2) {
26912 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26913 }
26914 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 (arg1)->SetDate((wxDateTime const &)*arg2);
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 resultobj = SWIG_Py_Void();
26922 return resultobj;
26923 fail:
26924 return NULL;
26925 }
26926
26927
26928 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26929 PyObject *obj;
26930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26931 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26932 return SWIG_Py_Void();
26933 }
26934
26935 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26936 return SWIG_Python_InitShadowInstance(args);
26937 }
26938
26939 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26940 PyObject *resultobj = 0;
26941 wxPyApp *result = 0 ;
26942
26943 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26944 {
26945 PyThreadState* __tstate = wxPyBeginAllowThreads();
26946 result = (wxPyApp *)new_wxPyApp();
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26951 return resultobj;
26952 fail:
26953 return NULL;
26954 }
26955
26956
26957 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26958 PyObject *resultobj = 0;
26959 wxPyApp *arg1 = (wxPyApp *) 0 ;
26960 void *argp1 = 0 ;
26961 int res1 = 0 ;
26962 PyObject *swig_obj[1] ;
26963
26964 if (!args) SWIG_fail;
26965 swig_obj[0] = args;
26966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26967 if (!SWIG_IsOK(res1)) {
26968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26969 }
26970 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 delete arg1;
26974
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 resultobj = SWIG_Py_Void();
26979 return resultobj;
26980 fail:
26981 return NULL;
26982 }
26983
26984
26985 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26986 PyObject *resultobj = 0;
26987 wxPyApp *arg1 = (wxPyApp *) 0 ;
26988 PyObject *arg2 = (PyObject *) 0 ;
26989 PyObject *arg3 = (PyObject *) 0 ;
26990 bool arg4 ;
26991 void *argp1 = 0 ;
26992 int res1 = 0 ;
26993 bool val4 ;
26994 int ecode4 = 0 ;
26995 PyObject * obj0 = 0 ;
26996 PyObject * obj1 = 0 ;
26997 PyObject * obj2 = 0 ;
26998 PyObject * obj3 = 0 ;
26999 char * kwnames[] = {
27000 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27001 };
27002
27003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27005 if (!SWIG_IsOK(res1)) {
27006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27007 }
27008 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27009 arg2 = obj1;
27010 arg3 = obj2;
27011 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27012 if (!SWIG_IsOK(ecode4)) {
27013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27014 }
27015 arg4 = static_cast< bool >(val4);
27016 {
27017 PyThreadState* __tstate = wxPyBeginAllowThreads();
27018 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27019 wxPyEndAllowThreads(__tstate);
27020 if (PyErr_Occurred()) SWIG_fail;
27021 }
27022 resultobj = SWIG_Py_Void();
27023 return resultobj;
27024 fail:
27025 return NULL;
27026 }
27027
27028
27029 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27030 PyObject *resultobj = 0;
27031 wxPyApp *arg1 = (wxPyApp *) 0 ;
27032 wxString result;
27033 void *argp1 = 0 ;
27034 int res1 = 0 ;
27035 PyObject *swig_obj[1] ;
27036
27037 if (!args) SWIG_fail;
27038 swig_obj[0] = args;
27039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27040 if (!SWIG_IsOK(res1)) {
27041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27042 }
27043 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27044 {
27045 PyThreadState* __tstate = wxPyBeginAllowThreads();
27046 result = ((wxPyApp const *)arg1)->GetAppName();
27047 wxPyEndAllowThreads(__tstate);
27048 if (PyErr_Occurred()) SWIG_fail;
27049 }
27050 {
27051 #if wxUSE_UNICODE
27052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27053 #else
27054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27055 #endif
27056 }
27057 return resultobj;
27058 fail:
27059 return NULL;
27060 }
27061
27062
27063 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27064 PyObject *resultobj = 0;
27065 wxPyApp *arg1 = (wxPyApp *) 0 ;
27066 wxString *arg2 = 0 ;
27067 void *argp1 = 0 ;
27068 int res1 = 0 ;
27069 bool temp2 = false ;
27070 PyObject * obj0 = 0 ;
27071 PyObject * obj1 = 0 ;
27072 char * kwnames[] = {
27073 (char *) "self",(char *) "name", NULL
27074 };
27075
27076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27078 if (!SWIG_IsOK(res1)) {
27079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27080 }
27081 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27082 {
27083 arg2 = wxString_in_helper(obj1);
27084 if (arg2 == NULL) SWIG_fail;
27085 temp2 = true;
27086 }
27087 {
27088 PyThreadState* __tstate = wxPyBeginAllowThreads();
27089 (arg1)->SetAppName((wxString const &)*arg2);
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 resultobj = SWIG_Py_Void();
27094 {
27095 if (temp2)
27096 delete arg2;
27097 }
27098 return resultobj;
27099 fail:
27100 {
27101 if (temp2)
27102 delete arg2;
27103 }
27104 return NULL;
27105 }
27106
27107
27108 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27109 PyObject *resultobj = 0;
27110 wxPyApp *arg1 = (wxPyApp *) 0 ;
27111 wxString result;
27112 void *argp1 = 0 ;
27113 int res1 = 0 ;
27114 PyObject *swig_obj[1] ;
27115
27116 if (!args) SWIG_fail;
27117 swig_obj[0] = args;
27118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27119 if (!SWIG_IsOK(res1)) {
27120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27121 }
27122 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 result = ((wxPyApp const *)arg1)->GetClassName();
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 {
27130 #if wxUSE_UNICODE
27131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27132 #else
27133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27134 #endif
27135 }
27136 return resultobj;
27137 fail:
27138 return NULL;
27139 }
27140
27141
27142 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27143 PyObject *resultobj = 0;
27144 wxPyApp *arg1 = (wxPyApp *) 0 ;
27145 wxString *arg2 = 0 ;
27146 void *argp1 = 0 ;
27147 int res1 = 0 ;
27148 bool temp2 = false ;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char * kwnames[] = {
27152 (char *) "self",(char *) "name", NULL
27153 };
27154
27155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27157 if (!SWIG_IsOK(res1)) {
27158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27159 }
27160 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27161 {
27162 arg2 = wxString_in_helper(obj1);
27163 if (arg2 == NULL) SWIG_fail;
27164 temp2 = true;
27165 }
27166 {
27167 PyThreadState* __tstate = wxPyBeginAllowThreads();
27168 (arg1)->SetClassName((wxString const &)*arg2);
27169 wxPyEndAllowThreads(__tstate);
27170 if (PyErr_Occurred()) SWIG_fail;
27171 }
27172 resultobj = SWIG_Py_Void();
27173 {
27174 if (temp2)
27175 delete arg2;
27176 }
27177 return resultobj;
27178 fail:
27179 {
27180 if (temp2)
27181 delete arg2;
27182 }
27183 return NULL;
27184 }
27185
27186
27187 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27188 PyObject *resultobj = 0;
27189 wxPyApp *arg1 = (wxPyApp *) 0 ;
27190 wxString *result = 0 ;
27191 void *argp1 = 0 ;
27192 int res1 = 0 ;
27193 PyObject *swig_obj[1] ;
27194
27195 if (!args) SWIG_fail;
27196 swig_obj[0] = args;
27197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27198 if (!SWIG_IsOK(res1)) {
27199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27200 }
27201 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 {
27205 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27206 result = (wxString *) &_result_ref;
27207 }
27208 wxPyEndAllowThreads(__tstate);
27209 if (PyErr_Occurred()) SWIG_fail;
27210 }
27211 {
27212 #if wxUSE_UNICODE
27213 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27214 #else
27215 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27216 #endif
27217 }
27218 return resultobj;
27219 fail:
27220 return NULL;
27221 }
27222
27223
27224 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27225 PyObject *resultobj = 0;
27226 wxPyApp *arg1 = (wxPyApp *) 0 ;
27227 wxString *arg2 = 0 ;
27228 void *argp1 = 0 ;
27229 int res1 = 0 ;
27230 bool temp2 = false ;
27231 PyObject * obj0 = 0 ;
27232 PyObject * obj1 = 0 ;
27233 char * kwnames[] = {
27234 (char *) "self",(char *) "name", NULL
27235 };
27236
27237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27239 if (!SWIG_IsOK(res1)) {
27240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27241 }
27242 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27243 {
27244 arg2 = wxString_in_helper(obj1);
27245 if (arg2 == NULL) SWIG_fail;
27246 temp2 = true;
27247 }
27248 {
27249 PyThreadState* __tstate = wxPyBeginAllowThreads();
27250 (arg1)->SetVendorName((wxString const &)*arg2);
27251 wxPyEndAllowThreads(__tstate);
27252 if (PyErr_Occurred()) SWIG_fail;
27253 }
27254 resultobj = SWIG_Py_Void();
27255 {
27256 if (temp2)
27257 delete arg2;
27258 }
27259 return resultobj;
27260 fail:
27261 {
27262 if (temp2)
27263 delete arg2;
27264 }
27265 return NULL;
27266 }
27267
27268
27269 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27270 PyObject *resultobj = 0;
27271 wxPyApp *arg1 = (wxPyApp *) 0 ;
27272 wxAppTraits *result = 0 ;
27273 void *argp1 = 0 ;
27274 int res1 = 0 ;
27275 PyObject *swig_obj[1] ;
27276
27277 if (!args) SWIG_fail;
27278 swig_obj[0] = args;
27279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27280 if (!SWIG_IsOK(res1)) {
27281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27282 }
27283 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27284 {
27285 PyThreadState* __tstate = wxPyBeginAllowThreads();
27286 result = (wxAppTraits *)(arg1)->GetTraits();
27287 wxPyEndAllowThreads(__tstate);
27288 if (PyErr_Occurred()) SWIG_fail;
27289 }
27290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27291 return resultobj;
27292 fail:
27293 return NULL;
27294 }
27295
27296
27297 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27298 PyObject *resultobj = 0;
27299 wxPyApp *arg1 = (wxPyApp *) 0 ;
27300 void *argp1 = 0 ;
27301 int res1 = 0 ;
27302 PyObject *swig_obj[1] ;
27303
27304 if (!args) SWIG_fail;
27305 swig_obj[0] = args;
27306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27307 if (!SWIG_IsOK(res1)) {
27308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27309 }
27310 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 (arg1)->ProcessPendingEvents();
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 resultobj = SWIG_Py_Void();
27318 return resultobj;
27319 fail:
27320 return NULL;
27321 }
27322
27323
27324 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27325 PyObject *resultobj = 0;
27326 wxPyApp *arg1 = (wxPyApp *) 0 ;
27327 bool arg2 = (bool) false ;
27328 bool result;
27329 void *argp1 = 0 ;
27330 int res1 = 0 ;
27331 bool val2 ;
27332 int ecode2 = 0 ;
27333 PyObject * obj0 = 0 ;
27334 PyObject * obj1 = 0 ;
27335 char * kwnames[] = {
27336 (char *) "self",(char *) "onlyIfNeeded", NULL
27337 };
27338
27339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27341 if (!SWIG_IsOK(res1)) {
27342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27343 }
27344 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27345 if (obj1) {
27346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27347 if (!SWIG_IsOK(ecode2)) {
27348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27349 }
27350 arg2 = static_cast< bool >(val2);
27351 }
27352 {
27353 PyThreadState* __tstate = wxPyBeginAllowThreads();
27354 result = (bool)(arg1)->Yield(arg2);
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 {
27359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27360 }
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27368 PyObject *resultobj = 0;
27369 wxPyApp *arg1 = (wxPyApp *) 0 ;
27370 void *argp1 = 0 ;
27371 int res1 = 0 ;
27372 PyObject *swig_obj[1] ;
27373
27374 if (!args) SWIG_fail;
27375 swig_obj[0] = args;
27376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27377 if (!SWIG_IsOK(res1)) {
27378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27379 }
27380 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27381 {
27382 PyThreadState* __tstate = wxPyBeginAllowThreads();
27383 (arg1)->WakeUpIdle();
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 resultobj = SWIG_Py_Void();
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27395 PyObject *resultobj = 0;
27396 bool result;
27397
27398 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (bool)wxPyApp::IsMainLoopRunning();
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27407 }
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27415 PyObject *resultobj = 0;
27416 wxPyApp *arg1 = (wxPyApp *) 0 ;
27417 int result;
27418 void *argp1 = 0 ;
27419 int res1 = 0 ;
27420 PyObject *swig_obj[1] ;
27421
27422 if (!args) SWIG_fail;
27423 swig_obj[0] = args;
27424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27425 if (!SWIG_IsOK(res1)) {
27426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27427 }
27428 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 result = (int)(arg1)->MainLoop();
27432 wxPyEndAllowThreads(__tstate);
27433 if (PyErr_Occurred()) SWIG_fail;
27434 }
27435 resultobj = SWIG_From_int(static_cast< int >(result));
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27443 PyObject *resultobj = 0;
27444 wxPyApp *arg1 = (wxPyApp *) 0 ;
27445 void *argp1 = 0 ;
27446 int res1 = 0 ;
27447 PyObject *swig_obj[1] ;
27448
27449 if (!args) SWIG_fail;
27450 swig_obj[0] = args;
27451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27452 if (!SWIG_IsOK(res1)) {
27453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27454 }
27455 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27456 {
27457 PyThreadState* __tstate = wxPyBeginAllowThreads();
27458 (arg1)->Exit();
27459 wxPyEndAllowThreads(__tstate);
27460 if (PyErr_Occurred()) SWIG_fail;
27461 }
27462 resultobj = SWIG_Py_Void();
27463 return resultobj;
27464 fail:
27465 return NULL;
27466 }
27467
27468
27469 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27470 PyObject *resultobj = 0;
27471 wxPyApp *arg1 = (wxPyApp *) 0 ;
27472 void *argp1 = 0 ;
27473 int res1 = 0 ;
27474 PyObject *swig_obj[1] ;
27475
27476 if (!args) SWIG_fail;
27477 swig_obj[0] = args;
27478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27479 if (!SWIG_IsOK(res1)) {
27480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27481 }
27482 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 (arg1)->ExitMainLoop();
27486 wxPyEndAllowThreads(__tstate);
27487 if (PyErr_Occurred()) SWIG_fail;
27488 }
27489 resultobj = SWIG_Py_Void();
27490 return resultobj;
27491 fail:
27492 return NULL;
27493 }
27494
27495
27496 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27497 PyObject *resultobj = 0;
27498 wxPyApp *arg1 = (wxPyApp *) 0 ;
27499 bool result;
27500 void *argp1 = 0 ;
27501 int res1 = 0 ;
27502 PyObject *swig_obj[1] ;
27503
27504 if (!args) SWIG_fail;
27505 swig_obj[0] = args;
27506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27507 if (!SWIG_IsOK(res1)) {
27508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27509 }
27510 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 result = (bool)(arg1)->Pending();
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 {
27518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27519 }
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27527 PyObject *resultobj = 0;
27528 wxPyApp *arg1 = (wxPyApp *) 0 ;
27529 bool result;
27530 void *argp1 = 0 ;
27531 int res1 = 0 ;
27532 PyObject *swig_obj[1] ;
27533
27534 if (!args) SWIG_fail;
27535 swig_obj[0] = args;
27536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27537 if (!SWIG_IsOK(res1)) {
27538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27539 }
27540 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 result = (bool)(arg1)->Dispatch();
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 {
27548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27549 }
27550 return resultobj;
27551 fail:
27552 return NULL;
27553 }
27554
27555
27556 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27557 PyObject *resultobj = 0;
27558 wxPyApp *arg1 = (wxPyApp *) 0 ;
27559 bool result;
27560 void *argp1 = 0 ;
27561 int res1 = 0 ;
27562 PyObject *swig_obj[1] ;
27563
27564 if (!args) SWIG_fail;
27565 swig_obj[0] = args;
27566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27567 if (!SWIG_IsOK(res1)) {
27568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27569 }
27570 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27571 {
27572 PyThreadState* __tstate = wxPyBeginAllowThreads();
27573 result = (bool)(arg1)->ProcessIdle();
27574 wxPyEndAllowThreads(__tstate);
27575 if (PyErr_Occurred()) SWIG_fail;
27576 }
27577 {
27578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27579 }
27580 return resultobj;
27581 fail:
27582 return NULL;
27583 }
27584
27585
27586 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27587 PyObject *resultobj = 0;
27588 wxPyApp *arg1 = (wxPyApp *) 0 ;
27589 wxWindow *arg2 = (wxWindow *) 0 ;
27590 wxIdleEvent *arg3 = 0 ;
27591 bool result;
27592 void *argp1 = 0 ;
27593 int res1 = 0 ;
27594 void *argp2 = 0 ;
27595 int res2 = 0 ;
27596 void *argp3 = 0 ;
27597 int res3 = 0 ;
27598 PyObject * obj0 = 0 ;
27599 PyObject * obj1 = 0 ;
27600 PyObject * obj2 = 0 ;
27601 char * kwnames[] = {
27602 (char *) "self",(char *) "win",(char *) "event", NULL
27603 };
27604
27605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27607 if (!SWIG_IsOK(res1)) {
27608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27609 }
27610 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27611 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27612 if (!SWIG_IsOK(res2)) {
27613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27614 }
27615 arg2 = reinterpret_cast< wxWindow * >(argp2);
27616 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27617 if (!SWIG_IsOK(res3)) {
27618 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27619 }
27620 if (!argp3) {
27621 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27622 }
27623 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27624 {
27625 PyThreadState* __tstate = wxPyBeginAllowThreads();
27626 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27627 wxPyEndAllowThreads(__tstate);
27628 if (PyErr_Occurred()) SWIG_fail;
27629 }
27630 {
27631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27632 }
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27640 PyObject *resultobj = 0;
27641 wxPyApp *arg1 = (wxPyApp *) 0 ;
27642 bool result;
27643 void *argp1 = 0 ;
27644 int res1 = 0 ;
27645 PyObject *swig_obj[1] ;
27646
27647 if (!args) SWIG_fail;
27648 swig_obj[0] = args;
27649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27650 if (!SWIG_IsOK(res1)) {
27651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27652 }
27653 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27654 {
27655 PyThreadState* __tstate = wxPyBeginAllowThreads();
27656 result = (bool)((wxPyApp const *)arg1)->IsActive();
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 {
27661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27662 }
27663 return resultobj;
27664 fail:
27665 return NULL;
27666 }
27667
27668
27669 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27670 PyObject *resultobj = 0;
27671 wxPyApp *arg1 = (wxPyApp *) 0 ;
27672 wxWindow *arg2 = (wxWindow *) 0 ;
27673 void *argp1 = 0 ;
27674 int res1 = 0 ;
27675 void *argp2 = 0 ;
27676 int res2 = 0 ;
27677 PyObject * obj0 = 0 ;
27678 PyObject * obj1 = 0 ;
27679 char * kwnames[] = {
27680 (char *) "self",(char *) "win", NULL
27681 };
27682
27683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27685 if (!SWIG_IsOK(res1)) {
27686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27687 }
27688 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27690 if (!SWIG_IsOK(res2)) {
27691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27692 }
27693 arg2 = reinterpret_cast< wxWindow * >(argp2);
27694 {
27695 PyThreadState* __tstate = wxPyBeginAllowThreads();
27696 (arg1)->SetTopWindow(arg2);
27697 wxPyEndAllowThreads(__tstate);
27698 if (PyErr_Occurred()) SWIG_fail;
27699 }
27700 resultobj = SWIG_Py_Void();
27701 return resultobj;
27702 fail:
27703 return NULL;
27704 }
27705
27706
27707 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27708 PyObject *resultobj = 0;
27709 wxPyApp *arg1 = (wxPyApp *) 0 ;
27710 wxWindow *result = 0 ;
27711 void *argp1 = 0 ;
27712 int res1 = 0 ;
27713 PyObject *swig_obj[1] ;
27714
27715 if (!args) SWIG_fail;
27716 swig_obj[0] = args;
27717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27718 if (!SWIG_IsOK(res1)) {
27719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27720 }
27721 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27725 wxPyEndAllowThreads(__tstate);
27726 if (PyErr_Occurred()) SWIG_fail;
27727 }
27728 {
27729 resultobj = wxPyMake_wxObject(result, (bool)0);
27730 }
27731 return resultobj;
27732 fail:
27733 return NULL;
27734 }
27735
27736
27737 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27738 PyObject *resultobj = 0;
27739 wxPyApp *arg1 = (wxPyApp *) 0 ;
27740 bool arg2 ;
27741 void *argp1 = 0 ;
27742 int res1 = 0 ;
27743 bool val2 ;
27744 int ecode2 = 0 ;
27745 PyObject * obj0 = 0 ;
27746 PyObject * obj1 = 0 ;
27747 char * kwnames[] = {
27748 (char *) "self",(char *) "flag", NULL
27749 };
27750
27751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27753 if (!SWIG_IsOK(res1)) {
27754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27755 }
27756 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27758 if (!SWIG_IsOK(ecode2)) {
27759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27760 }
27761 arg2 = static_cast< bool >(val2);
27762 {
27763 PyThreadState* __tstate = wxPyBeginAllowThreads();
27764 (arg1)->SetExitOnFrameDelete(arg2);
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 resultobj = SWIG_Py_Void();
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27776 PyObject *resultobj = 0;
27777 wxPyApp *arg1 = (wxPyApp *) 0 ;
27778 bool result;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 PyObject *swig_obj[1] ;
27782
27783 if (!args) SWIG_fail;
27784 swig_obj[0] = args;
27785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27786 if (!SWIG_IsOK(res1)) {
27787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27788 }
27789 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27790 {
27791 PyThreadState* __tstate = wxPyBeginAllowThreads();
27792 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27793 wxPyEndAllowThreads(__tstate);
27794 if (PyErr_Occurred()) SWIG_fail;
27795 }
27796 {
27797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27798 }
27799 return resultobj;
27800 fail:
27801 return NULL;
27802 }
27803
27804
27805 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27806 PyObject *resultobj = 0;
27807 wxPyApp *arg1 = (wxPyApp *) 0 ;
27808 bool arg2 ;
27809 void *argp1 = 0 ;
27810 int res1 = 0 ;
27811 bool val2 ;
27812 int ecode2 = 0 ;
27813 PyObject * obj0 = 0 ;
27814 PyObject * obj1 = 0 ;
27815 char * kwnames[] = {
27816 (char *) "self",(char *) "flag", NULL
27817 };
27818
27819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27821 if (!SWIG_IsOK(res1)) {
27822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27823 }
27824 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27825 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27826 if (!SWIG_IsOK(ecode2)) {
27827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27828 }
27829 arg2 = static_cast< bool >(val2);
27830 {
27831 PyThreadState* __tstate = wxPyBeginAllowThreads();
27832 (arg1)->SetUseBestVisual(arg2);
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 resultobj = SWIG_Py_Void();
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27844 PyObject *resultobj = 0;
27845 wxPyApp *arg1 = (wxPyApp *) 0 ;
27846 bool result;
27847 void *argp1 = 0 ;
27848 int res1 = 0 ;
27849 PyObject *swig_obj[1] ;
27850
27851 if (!args) SWIG_fail;
27852 swig_obj[0] = args;
27853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27854 if (!SWIG_IsOK(res1)) {
27855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27856 }
27857 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27858 {
27859 PyThreadState* __tstate = wxPyBeginAllowThreads();
27860 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27861 wxPyEndAllowThreads(__tstate);
27862 if (PyErr_Occurred()) SWIG_fail;
27863 }
27864 {
27865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27866 }
27867 return resultobj;
27868 fail:
27869 return NULL;
27870 }
27871
27872
27873 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27874 PyObject *resultobj = 0;
27875 wxPyApp *arg1 = (wxPyApp *) 0 ;
27876 int arg2 ;
27877 void *argp1 = 0 ;
27878 int res1 = 0 ;
27879 int val2 ;
27880 int ecode2 = 0 ;
27881 PyObject * obj0 = 0 ;
27882 PyObject * obj1 = 0 ;
27883 char * kwnames[] = {
27884 (char *) "self",(char *) "mode", NULL
27885 };
27886
27887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27889 if (!SWIG_IsOK(res1)) {
27890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27891 }
27892 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27893 ecode2 = SWIG_AsVal_int(obj1, &val2);
27894 if (!SWIG_IsOK(ecode2)) {
27895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27896 }
27897 arg2 = static_cast< int >(val2);
27898 {
27899 PyThreadState* __tstate = wxPyBeginAllowThreads();
27900 (arg1)->SetPrintMode(arg2);
27901 wxPyEndAllowThreads(__tstate);
27902 if (PyErr_Occurred()) SWIG_fail;
27903 }
27904 resultobj = SWIG_Py_Void();
27905 return resultobj;
27906 fail:
27907 return NULL;
27908 }
27909
27910
27911 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27912 PyObject *resultobj = 0;
27913 wxPyApp *arg1 = (wxPyApp *) 0 ;
27914 int result;
27915 void *argp1 = 0 ;
27916 int res1 = 0 ;
27917 PyObject *swig_obj[1] ;
27918
27919 if (!args) SWIG_fail;
27920 swig_obj[0] = args;
27921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27922 if (!SWIG_IsOK(res1)) {
27923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27924 }
27925 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27929 wxPyEndAllowThreads(__tstate);
27930 if (PyErr_Occurred()) SWIG_fail;
27931 }
27932 resultobj = SWIG_From_int(static_cast< int >(result));
27933 return resultobj;
27934 fail:
27935 return NULL;
27936 }
27937
27938
27939 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27940 PyObject *resultobj = 0;
27941 wxPyApp *arg1 = (wxPyApp *) 0 ;
27942 int arg2 ;
27943 void *argp1 = 0 ;
27944 int res1 = 0 ;
27945 int val2 ;
27946 int ecode2 = 0 ;
27947 PyObject * obj0 = 0 ;
27948 PyObject * obj1 = 0 ;
27949 char * kwnames[] = {
27950 (char *) "self",(char *) "mode", NULL
27951 };
27952
27953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27955 if (!SWIG_IsOK(res1)) {
27956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27957 }
27958 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27959 ecode2 = SWIG_AsVal_int(obj1, &val2);
27960 if (!SWIG_IsOK(ecode2)) {
27961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27962 }
27963 arg2 = static_cast< int >(val2);
27964 {
27965 PyThreadState* __tstate = wxPyBeginAllowThreads();
27966 (arg1)->SetAssertMode(arg2);
27967 wxPyEndAllowThreads(__tstate);
27968 if (PyErr_Occurred()) SWIG_fail;
27969 }
27970 resultobj = SWIG_Py_Void();
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27978 PyObject *resultobj = 0;
27979 wxPyApp *arg1 = (wxPyApp *) 0 ;
27980 int result;
27981 void *argp1 = 0 ;
27982 int res1 = 0 ;
27983 PyObject *swig_obj[1] ;
27984
27985 if (!args) SWIG_fail;
27986 swig_obj[0] = args;
27987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27988 if (!SWIG_IsOK(res1)) {
27989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27990 }
27991 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 result = (int)(arg1)->GetAssertMode();
27995 wxPyEndAllowThreads(__tstate);
27996 if (PyErr_Occurred()) SWIG_fail;
27997 }
27998 resultobj = SWIG_From_int(static_cast< int >(result));
27999 return resultobj;
28000 fail:
28001 return NULL;
28002 }
28003
28004
28005 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28006 PyObject *resultobj = 0;
28007 bool result;
28008
28009 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 {
28017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28018 }
28019 return resultobj;
28020 fail:
28021 return NULL;
28022 }
28023
28024
28025 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28026 PyObject *resultobj = 0;
28027 long result;
28028
28029 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 result = (long)wxPyApp::GetMacAboutMenuItemId();
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 resultobj = SWIG_From_long(static_cast< long >(result));
28037 return resultobj;
28038 fail:
28039 return NULL;
28040 }
28041
28042
28043 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28044 PyObject *resultobj = 0;
28045 long result;
28046
28047 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28048 {
28049 PyThreadState* __tstate = wxPyBeginAllowThreads();
28050 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28051 wxPyEndAllowThreads(__tstate);
28052 if (PyErr_Occurred()) SWIG_fail;
28053 }
28054 resultobj = SWIG_From_long(static_cast< long >(result));
28055 return resultobj;
28056 fail:
28057 return NULL;
28058 }
28059
28060
28061 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28062 PyObject *resultobj = 0;
28063 long result;
28064
28065 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28066 {
28067 PyThreadState* __tstate = wxPyBeginAllowThreads();
28068 result = (long)wxPyApp::GetMacExitMenuItemId();
28069 wxPyEndAllowThreads(__tstate);
28070 if (PyErr_Occurred()) SWIG_fail;
28071 }
28072 resultobj = SWIG_From_long(static_cast< long >(result));
28073 return resultobj;
28074 fail:
28075 return NULL;
28076 }
28077
28078
28079 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28080 PyObject *resultobj = 0;
28081 wxString result;
28082
28083 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28084 {
28085 PyThreadState* __tstate = wxPyBeginAllowThreads();
28086 result = wxPyApp::GetMacHelpMenuTitleName();
28087 wxPyEndAllowThreads(__tstate);
28088 if (PyErr_Occurred()) SWIG_fail;
28089 }
28090 {
28091 #if wxUSE_UNICODE
28092 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28093 #else
28094 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28095 #endif
28096 }
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj = 0;
28105 bool arg1 ;
28106 bool val1 ;
28107 int ecode1 = 0 ;
28108 PyObject * obj0 = 0 ;
28109 char * kwnames[] = {
28110 (char *) "val", NULL
28111 };
28112
28113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28114 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28115 if (!SWIG_IsOK(ecode1)) {
28116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28117 }
28118 arg1 = static_cast< bool >(val1);
28119 {
28120 PyThreadState* __tstate = wxPyBeginAllowThreads();
28121 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28122 wxPyEndAllowThreads(__tstate);
28123 if (PyErr_Occurred()) SWIG_fail;
28124 }
28125 resultobj = SWIG_Py_Void();
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 long arg1 ;
28135 long val1 ;
28136 int ecode1 = 0 ;
28137 PyObject * obj0 = 0 ;
28138 char * kwnames[] = {
28139 (char *) "val", NULL
28140 };
28141
28142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28143 ecode1 = SWIG_AsVal_long(obj0, &val1);
28144 if (!SWIG_IsOK(ecode1)) {
28145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28146 }
28147 arg1 = static_cast< long >(val1);
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 wxPyApp::SetMacAboutMenuItemId(arg1);
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_Py_Void();
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj = 0;
28163 long arg1 ;
28164 long val1 ;
28165 int ecode1 = 0 ;
28166 PyObject * obj0 = 0 ;
28167 char * kwnames[] = {
28168 (char *) "val", NULL
28169 };
28170
28171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28172 ecode1 = SWIG_AsVal_long(obj0, &val1);
28173 if (!SWIG_IsOK(ecode1)) {
28174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28175 }
28176 arg1 = static_cast< long >(val1);
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 resultobj = SWIG_Py_Void();
28184 return resultobj;
28185 fail:
28186 return NULL;
28187 }
28188
28189
28190 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28191 PyObject *resultobj = 0;
28192 long arg1 ;
28193 long val1 ;
28194 int ecode1 = 0 ;
28195 PyObject * obj0 = 0 ;
28196 char * kwnames[] = {
28197 (char *) "val", NULL
28198 };
28199
28200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28201 ecode1 = SWIG_AsVal_long(obj0, &val1);
28202 if (!SWIG_IsOK(ecode1)) {
28203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28204 }
28205 arg1 = static_cast< long >(val1);
28206 {
28207 PyThreadState* __tstate = wxPyBeginAllowThreads();
28208 wxPyApp::SetMacExitMenuItemId(arg1);
28209 wxPyEndAllowThreads(__tstate);
28210 if (PyErr_Occurred()) SWIG_fail;
28211 }
28212 resultobj = SWIG_Py_Void();
28213 return resultobj;
28214 fail:
28215 return NULL;
28216 }
28217
28218
28219 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28220 PyObject *resultobj = 0;
28221 wxString *arg1 = 0 ;
28222 bool temp1 = false ;
28223 PyObject * obj0 = 0 ;
28224 char * kwnames[] = {
28225 (char *) "val", NULL
28226 };
28227
28228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28229 {
28230 arg1 = wxString_in_helper(obj0);
28231 if (arg1 == NULL) SWIG_fail;
28232 temp1 = true;
28233 }
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28237 wxPyEndAllowThreads(__tstate);
28238 if (PyErr_Occurred()) SWIG_fail;
28239 }
28240 resultobj = SWIG_Py_Void();
28241 {
28242 if (temp1)
28243 delete arg1;
28244 }
28245 return resultobj;
28246 fail:
28247 {
28248 if (temp1)
28249 delete arg1;
28250 }
28251 return NULL;
28252 }
28253
28254
28255 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28256 PyObject *resultobj = 0;
28257 wxPyApp *arg1 = (wxPyApp *) 0 ;
28258 void *argp1 = 0 ;
28259 int res1 = 0 ;
28260 PyObject *swig_obj[1] ;
28261
28262 if (!args) SWIG_fail;
28263 swig_obj[0] = args;
28264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28265 if (!SWIG_IsOK(res1)) {
28266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28267 }
28268 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28269 {
28270 PyThreadState* __tstate = wxPyBeginAllowThreads();
28271 (arg1)->_BootstrapApp();
28272 wxPyEndAllowThreads(__tstate);
28273 if (PyErr_Occurred()) SWIG_fail;
28274 }
28275 resultobj = SWIG_Py_Void();
28276 return resultobj;
28277 fail:
28278 return NULL;
28279 }
28280
28281
28282 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28283 PyObject *resultobj = 0;
28284 int result;
28285
28286 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28287 {
28288 PyThreadState* __tstate = wxPyBeginAllowThreads();
28289 result = (int)wxPyApp::GetComCtl32Version();
28290 wxPyEndAllowThreads(__tstate);
28291 if (PyErr_Occurred()) SWIG_fail;
28292 }
28293 resultobj = SWIG_From_int(static_cast< int >(result));
28294 return resultobj;
28295 fail:
28296 return NULL;
28297 }
28298
28299
28300 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28301 PyObject *obj;
28302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28303 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28304 return SWIG_Py_Void();
28305 }
28306
28307 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 return SWIG_Python_InitShadowInstance(args);
28309 }
28310
28311 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28312 PyObject *resultobj = 0;
28313
28314 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28315 {
28316 PyThreadState* __tstate = wxPyBeginAllowThreads();
28317 wxExit();
28318 wxPyEndAllowThreads(__tstate);
28319 if (PyErr_Occurred()) SWIG_fail;
28320 }
28321 resultobj = SWIG_Py_Void();
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28329 PyObject *resultobj = 0;
28330 bool result;
28331
28332 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28333 {
28334 PyThreadState* __tstate = wxPyBeginAllowThreads();
28335 result = (bool)wxYield();
28336 wxPyEndAllowThreads(__tstate);
28337 if (PyErr_Occurred()) SWIG_fail;
28338 }
28339 {
28340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28341 }
28342 return resultobj;
28343 fail:
28344 return NULL;
28345 }
28346
28347
28348 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28349 PyObject *resultobj = 0;
28350 bool result;
28351
28352 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 result = (bool)wxYieldIfNeeded();
28356 wxPyEndAllowThreads(__tstate);
28357 if (PyErr_Occurred()) SWIG_fail;
28358 }
28359 {
28360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28361 }
28362 return resultobj;
28363 fail:
28364 return NULL;
28365 }
28366
28367
28368 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28369 PyObject *resultobj = 0;
28370 wxWindow *arg1 = (wxWindow *) NULL ;
28371 bool arg2 = (bool) false ;
28372 bool result;
28373 void *argp1 = 0 ;
28374 int res1 = 0 ;
28375 bool val2 ;
28376 int ecode2 = 0 ;
28377 PyObject * obj0 = 0 ;
28378 PyObject * obj1 = 0 ;
28379 char * kwnames[] = {
28380 (char *) "win",(char *) "onlyIfNeeded", NULL
28381 };
28382
28383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28384 if (obj0) {
28385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28386 if (!SWIG_IsOK(res1)) {
28387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28388 }
28389 arg1 = reinterpret_cast< wxWindow * >(argp1);
28390 }
28391 if (obj1) {
28392 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28393 if (!SWIG_IsOK(ecode2)) {
28394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28395 }
28396 arg2 = static_cast< bool >(val2);
28397 }
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 result = (bool)wxSafeYield(arg1,arg2);
28401 wxPyEndAllowThreads(__tstate);
28402 if (PyErr_Occurred()) SWIG_fail;
28403 }
28404 {
28405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28406 }
28407 return resultobj;
28408 fail:
28409 return NULL;
28410 }
28411
28412
28413 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28414 PyObject *resultobj = 0;
28415
28416 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28417 {
28418 PyThreadState* __tstate = wxPyBeginAllowThreads();
28419 wxWakeUpIdle();
28420 wxPyEndAllowThreads(__tstate);
28421 if (PyErr_Occurred()) SWIG_fail;
28422 }
28423 resultobj = SWIG_Py_Void();
28424 return resultobj;
28425 fail:
28426 return NULL;
28427 }
28428
28429
28430 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28431 PyObject *resultobj = 0;
28432 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28433 wxEvent *arg2 = 0 ;
28434 void *argp1 = 0 ;
28435 int res1 = 0 ;
28436 void *argp2 = 0 ;
28437 int res2 = 0 ;
28438 PyObject * obj0 = 0 ;
28439 PyObject * obj1 = 0 ;
28440 char * kwnames[] = {
28441 (char *) "dest",(char *) "event", NULL
28442 };
28443
28444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28446 if (!SWIG_IsOK(res1)) {
28447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28448 }
28449 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28451 if (!SWIG_IsOK(res2)) {
28452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28453 }
28454 if (!argp2) {
28455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28456 }
28457 arg2 = reinterpret_cast< wxEvent * >(argp2);
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 wxPostEvent(arg1,*arg2);
28461 wxPyEndAllowThreads(__tstate);
28462 if (PyErr_Occurred()) SWIG_fail;
28463 }
28464 resultobj = SWIG_Py_Void();
28465 return resultobj;
28466 fail:
28467 return NULL;
28468 }
28469
28470
28471 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28472 PyObject *resultobj = 0;
28473
28474 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 wxApp_CleanUp();
28478 wxPyEndAllowThreads(__tstate);
28479 if (PyErr_Occurred()) SWIG_fail;
28480 }
28481 resultobj = SWIG_Py_Void();
28482 return resultobj;
28483 fail:
28484 return NULL;
28485 }
28486
28487
28488 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28489 PyObject *resultobj = 0;
28490 wxPyApp *result = 0 ;
28491
28492 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28493 {
28494 PyThreadState* __tstate = wxPyBeginAllowThreads();
28495 result = (wxPyApp *)wxPyGetApp();
28496 wxPyEndAllowThreads(__tstate);
28497 if (PyErr_Occurred()) SWIG_fail;
28498 }
28499 {
28500 resultobj = wxPyMake_wxObject(result, 0);
28501 }
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28509 PyObject *resultobj = 0;
28510 char *arg1 = (char *) 0 ;
28511 int res1 ;
28512 char *buf1 = 0 ;
28513 int alloc1 = 0 ;
28514 PyObject * obj0 = 0 ;
28515 char * kwnames[] = {
28516 (char *) "encoding", NULL
28517 };
28518
28519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28520 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28521 if (!SWIG_IsOK(res1)) {
28522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28523 }
28524 arg1 = buf1;
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 wxSetDefaultPyEncoding((char const *)arg1);
28528 wxPyEndAllowThreads(__tstate);
28529 if (PyErr_Occurred()) SWIG_fail;
28530 }
28531 resultobj = SWIG_Py_Void();
28532 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28533 return resultobj;
28534 fail:
28535 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28536 return NULL;
28537 }
28538
28539
28540 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28541 PyObject *resultobj = 0;
28542 char *result = 0 ;
28543
28544 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 result = (char *)wxGetDefaultPyEncoding();
28548 wxPyEndAllowThreads(__tstate);
28549 if (PyErr_Occurred()) SWIG_fail;
28550 }
28551 resultobj = SWIG_FromCharPtr(result);
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 PyObject *resultobj = 0;
28560 wxEventLoop *result = 0 ;
28561
28562 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28563 {
28564 PyThreadState* __tstate = wxPyBeginAllowThreads();
28565 result = (wxEventLoop *)new wxEventLoop();
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28577 PyObject *resultobj = 0;
28578 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28579 void *argp1 = 0 ;
28580 int res1 = 0 ;
28581 PyObject *swig_obj[1] ;
28582
28583 if (!args) SWIG_fail;
28584 swig_obj[0] = args;
28585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28586 if (!SWIG_IsOK(res1)) {
28587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28588 }
28589 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28590 {
28591 PyThreadState* __tstate = wxPyBeginAllowThreads();
28592 delete arg1;
28593
28594 wxPyEndAllowThreads(__tstate);
28595 if (PyErr_Occurred()) SWIG_fail;
28596 }
28597 resultobj = SWIG_Py_Void();
28598 return resultobj;
28599 fail:
28600 return NULL;
28601 }
28602
28603
28604 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28605 PyObject *resultobj = 0;
28606 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28607 int result;
28608 void *argp1 = 0 ;
28609 int res1 = 0 ;
28610 PyObject *swig_obj[1] ;
28611
28612 if (!args) SWIG_fail;
28613 swig_obj[0] = args;
28614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28615 if (!SWIG_IsOK(res1)) {
28616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28617 }
28618 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 result = (int)(arg1)->Run();
28622 wxPyEndAllowThreads(__tstate);
28623 if (PyErr_Occurred()) SWIG_fail;
28624 }
28625 resultobj = SWIG_From_int(static_cast< int >(result));
28626 return resultobj;
28627 fail:
28628 return NULL;
28629 }
28630
28631
28632 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28633 PyObject *resultobj = 0;
28634 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28635 int arg2 = (int) 0 ;
28636 void *argp1 = 0 ;
28637 int res1 = 0 ;
28638 int val2 ;
28639 int ecode2 = 0 ;
28640 PyObject * obj0 = 0 ;
28641 PyObject * obj1 = 0 ;
28642 char * kwnames[] = {
28643 (char *) "self",(char *) "rc", NULL
28644 };
28645
28646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28648 if (!SWIG_IsOK(res1)) {
28649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28650 }
28651 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28652 if (obj1) {
28653 ecode2 = SWIG_AsVal_int(obj1, &val2);
28654 if (!SWIG_IsOK(ecode2)) {
28655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28656 }
28657 arg2 = static_cast< int >(val2);
28658 }
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 (arg1)->Exit(arg2);
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 resultobj = SWIG_Py_Void();
28666 return resultobj;
28667 fail:
28668 return NULL;
28669 }
28670
28671
28672 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28673 PyObject *resultobj = 0;
28674 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28675 bool result;
28676 void *argp1 = 0 ;
28677 int res1 = 0 ;
28678 PyObject *swig_obj[1] ;
28679
28680 if (!args) SWIG_fail;
28681 swig_obj[0] = args;
28682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28683 if (!SWIG_IsOK(res1)) {
28684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28685 }
28686 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 result = (bool)((wxEventLoop const *)arg1)->Pending();
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 {
28694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28695 }
28696 return resultobj;
28697 fail:
28698 return NULL;
28699 }
28700
28701
28702 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28703 PyObject *resultobj = 0;
28704 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28705 bool result;
28706 void *argp1 = 0 ;
28707 int res1 = 0 ;
28708 PyObject *swig_obj[1] ;
28709
28710 if (!args) SWIG_fail;
28711 swig_obj[0] = args;
28712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28713 if (!SWIG_IsOK(res1)) {
28714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28715 }
28716 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 result = (bool)(arg1)->Dispatch();
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 {
28724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28725 }
28726 return resultobj;
28727 fail:
28728 return NULL;
28729 }
28730
28731
28732 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28733 PyObject *resultobj = 0;
28734 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28735 bool result;
28736 void *argp1 = 0 ;
28737 int res1 = 0 ;
28738 PyObject *swig_obj[1] ;
28739
28740 if (!args) SWIG_fail;
28741 swig_obj[0] = args;
28742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28743 if (!SWIG_IsOK(res1)) {
28744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28745 }
28746 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28747 {
28748 PyThreadState* __tstate = wxPyBeginAllowThreads();
28749 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28750 wxPyEndAllowThreads(__tstate);
28751 if (PyErr_Occurred()) SWIG_fail;
28752 }
28753 {
28754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28755 }
28756 return resultobj;
28757 fail:
28758 return NULL;
28759 }
28760
28761
28762 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28763 PyObject *resultobj = 0;
28764 wxEventLoop *result = 0 ;
28765
28766 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 result = (wxEventLoop *)wxEventLoop::GetActive();
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28781 PyObject *resultobj = 0;
28782 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28783 void *argp1 = 0 ;
28784 int res1 = 0 ;
28785 PyObject * obj0 = 0 ;
28786 char * kwnames[] = {
28787 (char *) "loop", NULL
28788 };
28789
28790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28792 if (!SWIG_IsOK(res1)) {
28793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28794 }
28795 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 wxEventLoop::SetActive(arg1);
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 resultobj = SWIG_Py_Void();
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28810 PyObject *obj;
28811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28812 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28813 return SWIG_Py_Void();
28814 }
28815
28816 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28817 return SWIG_Python_InitShadowInstance(args);
28818 }
28819
28820 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28821 PyObject *resultobj = 0;
28822 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28823 wxEventLoopActivator *result = 0 ;
28824 void *argp1 = 0 ;
28825 int res1 = 0 ;
28826 PyObject * obj0 = 0 ;
28827 char * kwnames[] = {
28828 (char *) "evtLoop", NULL
28829 };
28830
28831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28833 if (!SWIG_IsOK(res1)) {
28834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28835 }
28836 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28840 wxPyEndAllowThreads(__tstate);
28841 if (PyErr_Occurred()) SWIG_fail;
28842 }
28843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28844 return resultobj;
28845 fail:
28846 return NULL;
28847 }
28848
28849
28850 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28851 PyObject *resultobj = 0;
28852 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28853 void *argp1 = 0 ;
28854 int res1 = 0 ;
28855 PyObject *swig_obj[1] ;
28856
28857 if (!args) SWIG_fail;
28858 swig_obj[0] = args;
28859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28860 if (!SWIG_IsOK(res1)) {
28861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28862 }
28863 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28864 {
28865 PyThreadState* __tstate = wxPyBeginAllowThreads();
28866 delete arg1;
28867
28868 wxPyEndAllowThreads(__tstate);
28869 if (PyErr_Occurred()) SWIG_fail;
28870 }
28871 resultobj = SWIG_Py_Void();
28872 return resultobj;
28873 fail:
28874 return NULL;
28875 }
28876
28877
28878 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28879 PyObject *obj;
28880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28881 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28882 return SWIG_Py_Void();
28883 }
28884
28885 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28886 return SWIG_Python_InitShadowInstance(args);
28887 }
28888
28889 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj = 0;
28891 int arg1 = (int) 0 ;
28892 int arg2 = (int) 0 ;
28893 int arg3 = (int) 0 ;
28894 wxAcceleratorEntry *result = 0 ;
28895 int val1 ;
28896 int ecode1 = 0 ;
28897 int val2 ;
28898 int ecode2 = 0 ;
28899 int val3 ;
28900 int ecode3 = 0 ;
28901 PyObject * obj0 = 0 ;
28902 PyObject * obj1 = 0 ;
28903 PyObject * obj2 = 0 ;
28904 char * kwnames[] = {
28905 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28906 };
28907
28908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28909 if (obj0) {
28910 ecode1 = SWIG_AsVal_int(obj0, &val1);
28911 if (!SWIG_IsOK(ecode1)) {
28912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28913 }
28914 arg1 = static_cast< int >(val1);
28915 }
28916 if (obj1) {
28917 ecode2 = SWIG_AsVal_int(obj1, &val2);
28918 if (!SWIG_IsOK(ecode2)) {
28919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28920 }
28921 arg2 = static_cast< int >(val2);
28922 }
28923 if (obj2) {
28924 ecode3 = SWIG_AsVal_int(obj2, &val3);
28925 if (!SWIG_IsOK(ecode3)) {
28926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28927 }
28928 arg3 = static_cast< int >(val3);
28929 }
28930 {
28931 PyThreadState* __tstate = wxPyBeginAllowThreads();
28932 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 PyObject *resultobj = 0;
28945 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28946 void *argp1 = 0 ;
28947 int res1 = 0 ;
28948 PyObject *swig_obj[1] ;
28949
28950 if (!args) SWIG_fail;
28951 swig_obj[0] = args;
28952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28953 if (!SWIG_IsOK(res1)) {
28954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28955 }
28956 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 delete arg1;
28960
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 resultobj = SWIG_Py_Void();
28965 return resultobj;
28966 fail:
28967 return NULL;
28968 }
28969
28970
28971 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28972 PyObject *resultobj = 0;
28973 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28974 int arg2 ;
28975 int arg3 ;
28976 int arg4 ;
28977 void *argp1 = 0 ;
28978 int res1 = 0 ;
28979 int val2 ;
28980 int ecode2 = 0 ;
28981 int val3 ;
28982 int ecode3 = 0 ;
28983 int val4 ;
28984 int ecode4 = 0 ;
28985 PyObject * obj0 = 0 ;
28986 PyObject * obj1 = 0 ;
28987 PyObject * obj2 = 0 ;
28988 PyObject * obj3 = 0 ;
28989 char * kwnames[] = {
28990 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28991 };
28992
28993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28995 if (!SWIG_IsOK(res1)) {
28996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28997 }
28998 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28999 ecode2 = SWIG_AsVal_int(obj1, &val2);
29000 if (!SWIG_IsOK(ecode2)) {
29001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29002 }
29003 arg2 = static_cast< int >(val2);
29004 ecode3 = SWIG_AsVal_int(obj2, &val3);
29005 if (!SWIG_IsOK(ecode3)) {
29006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29007 }
29008 arg3 = static_cast< int >(val3);
29009 ecode4 = SWIG_AsVal_int(obj3, &val4);
29010 if (!SWIG_IsOK(ecode4)) {
29011 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29012 }
29013 arg4 = static_cast< int >(val4);
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 (arg1)->Set(arg2,arg3,arg4);
29017 wxPyEndAllowThreads(__tstate);
29018 if (PyErr_Occurred()) SWIG_fail;
29019 }
29020 resultobj = SWIG_Py_Void();
29021 return resultobj;
29022 fail:
29023 return NULL;
29024 }
29025
29026
29027 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29028 PyObject *resultobj = 0;
29029 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29030 int result;
29031 void *argp1 = 0 ;
29032 int res1 = 0 ;
29033 PyObject *swig_obj[1] ;
29034
29035 if (!args) SWIG_fail;
29036 swig_obj[0] = args;
29037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29038 if (!SWIG_IsOK(res1)) {
29039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29040 }
29041 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29042 {
29043 PyThreadState* __tstate = wxPyBeginAllowThreads();
29044 result = (int)(arg1)->GetFlags();
29045 wxPyEndAllowThreads(__tstate);
29046 if (PyErr_Occurred()) SWIG_fail;
29047 }
29048 resultobj = SWIG_From_int(static_cast< int >(result));
29049 return resultobj;
29050 fail:
29051 return NULL;
29052 }
29053
29054
29055 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29056 PyObject *resultobj = 0;
29057 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29058 int result;
29059 void *argp1 = 0 ;
29060 int res1 = 0 ;
29061 PyObject *swig_obj[1] ;
29062
29063 if (!args) SWIG_fail;
29064 swig_obj[0] = args;
29065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29066 if (!SWIG_IsOK(res1)) {
29067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29068 }
29069 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29070 {
29071 PyThreadState* __tstate = wxPyBeginAllowThreads();
29072 result = (int)(arg1)->GetKeyCode();
29073 wxPyEndAllowThreads(__tstate);
29074 if (PyErr_Occurred()) SWIG_fail;
29075 }
29076 resultobj = SWIG_From_int(static_cast< int >(result));
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29084 PyObject *resultobj = 0;
29085 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29086 int result;
29087 void *argp1 = 0 ;
29088 int res1 = 0 ;
29089 PyObject *swig_obj[1] ;
29090
29091 if (!args) SWIG_fail;
29092 swig_obj[0] = args;
29093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29096 }
29097 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (int)(arg1)->GetCommand();
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 resultobj = SWIG_From_int(static_cast< int >(result));
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29112 PyObject *obj;
29113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29114 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29115 return SWIG_Py_Void();
29116 }
29117
29118 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29119 return SWIG_Python_InitShadowInstance(args);
29120 }
29121
29122 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29123 PyObject *resultobj = 0;
29124 int arg1 ;
29125 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29126 wxAcceleratorTable *result = 0 ;
29127 PyObject * obj0 = 0 ;
29128 char * kwnames[] = {
29129 (char *) "n", NULL
29130 };
29131
29132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29133 {
29134 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29135 if (arg2) arg1 = PyList_Size(obj0);
29136 else arg1 = 0;
29137 }
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29141 wxPyEndAllowThreads(__tstate);
29142 if (PyErr_Occurred()) SWIG_fail;
29143 }
29144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29145 return resultobj;
29146 fail:
29147 return NULL;
29148 }
29149
29150
29151 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29152 PyObject *resultobj = 0;
29153 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29154 void *argp1 = 0 ;
29155 int res1 = 0 ;
29156 PyObject *swig_obj[1] ;
29157
29158 if (!args) SWIG_fail;
29159 swig_obj[0] = args;
29160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29161 if (!SWIG_IsOK(res1)) {
29162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29163 }
29164 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29165 {
29166 PyThreadState* __tstate = wxPyBeginAllowThreads();
29167 delete arg1;
29168
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 resultobj = SWIG_Py_Void();
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29180 PyObject *resultobj = 0;
29181 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29182 bool result;
29183 void *argp1 = 0 ;
29184 int res1 = 0 ;
29185 PyObject *swig_obj[1] ;
29186
29187 if (!args) SWIG_fail;
29188 swig_obj[0] = args;
29189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29190 if (!SWIG_IsOK(res1)) {
29191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29192 }
29193 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29197 wxPyEndAllowThreads(__tstate);
29198 if (PyErr_Occurred()) SWIG_fail;
29199 }
29200 {
29201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29202 }
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29210 PyObject *obj;
29211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29212 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29213 return SWIG_Py_Void();
29214 }
29215
29216 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29217 return SWIG_Python_InitShadowInstance(args);
29218 }
29219
29220 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29221 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29222 return 1;
29223 }
29224
29225
29226 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29227 PyObject *pyobj = 0;
29228
29229 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29230 return pyobj;
29231 }
29232
29233
29234 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29235 PyObject *resultobj = 0;
29236 wxString *arg1 = 0 ;
29237 wxAcceleratorEntry *result = 0 ;
29238 bool temp1 = false ;
29239 PyObject * obj0 = 0 ;
29240 char * kwnames[] = {
29241 (char *) "label", NULL
29242 };
29243
29244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29245 {
29246 arg1 = wxString_in_helper(obj0);
29247 if (arg1 == NULL) SWIG_fail;
29248 temp1 = true;
29249 }
29250 {
29251 PyThreadState* __tstate = wxPyBeginAllowThreads();
29252 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29253 wxPyEndAllowThreads(__tstate);
29254 if (PyErr_Occurred()) SWIG_fail;
29255 }
29256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29257 {
29258 if (temp1)
29259 delete arg1;
29260 }
29261 return resultobj;
29262 fail:
29263 {
29264 if (temp1)
29265 delete arg1;
29266 }
29267 return NULL;
29268 }
29269
29270
29271 SWIGINTERN int PanelNameStr_set(PyObject *) {
29272 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29273 return 1;
29274 }
29275
29276
29277 SWIGINTERN PyObject *PanelNameStr_get(void) {
29278 PyObject *pyobj = 0;
29279
29280 {
29281 #if wxUSE_UNICODE
29282 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29283 #else
29284 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29285 #endif
29286 }
29287 return pyobj;
29288 }
29289
29290
29291 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29292 PyObject *resultobj = 0;
29293 wxVisualAttributes *result = 0 ;
29294
29295 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29296 {
29297 PyThreadState* __tstate = wxPyBeginAllowThreads();
29298 result = (wxVisualAttributes *)new_wxVisualAttributes();
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29310 PyObject *resultobj = 0;
29311 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29312 void *argp1 = 0 ;
29313 int res1 = 0 ;
29314 PyObject *swig_obj[1] ;
29315
29316 if (!args) SWIG_fail;
29317 swig_obj[0] = args;
29318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29319 if (!SWIG_IsOK(res1)) {
29320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29321 }
29322 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29323 {
29324 PyThreadState* __tstate = wxPyBeginAllowThreads();
29325 delete_wxVisualAttributes(arg1);
29326
29327 wxPyEndAllowThreads(__tstate);
29328 if (PyErr_Occurred()) SWIG_fail;
29329 }
29330 resultobj = SWIG_Py_Void();
29331 return resultobj;
29332 fail:
29333 return NULL;
29334 }
29335
29336
29337 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29338 PyObject *resultobj = 0;
29339 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29340 wxFont *arg2 = (wxFont *) 0 ;
29341 void *argp1 = 0 ;
29342 int res1 = 0 ;
29343 void *argp2 = 0 ;
29344 int res2 = 0 ;
29345 PyObject *swig_obj[2] ;
29346
29347 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29349 if (!SWIG_IsOK(res1)) {
29350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29351 }
29352 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29353 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29354 if (!SWIG_IsOK(res2)) {
29355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29356 }
29357 arg2 = reinterpret_cast< wxFont * >(argp2);
29358 if (arg1) (arg1)->font = *arg2;
29359
29360 resultobj = SWIG_Py_Void();
29361 return resultobj;
29362 fail:
29363 return NULL;
29364 }
29365
29366
29367 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29368 PyObject *resultobj = 0;
29369 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29370 wxFont *result = 0 ;
29371 void *argp1 = 0 ;
29372 int res1 = 0 ;
29373 PyObject *swig_obj[1] ;
29374
29375 if (!args) SWIG_fail;
29376 swig_obj[0] = args;
29377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29378 if (!SWIG_IsOK(res1)) {
29379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29380 }
29381 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29382 result = (wxFont *)& ((arg1)->font);
29383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29384 return resultobj;
29385 fail:
29386 return NULL;
29387 }
29388
29389
29390 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29391 PyObject *resultobj = 0;
29392 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29393 wxColour *arg2 = (wxColour *) 0 ;
29394 void *argp1 = 0 ;
29395 int res1 = 0 ;
29396 void *argp2 = 0 ;
29397 int res2 = 0 ;
29398 PyObject *swig_obj[2] ;
29399
29400 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29402 if (!SWIG_IsOK(res1)) {
29403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29404 }
29405 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29406 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29407 if (!SWIG_IsOK(res2)) {
29408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29409 }
29410 arg2 = reinterpret_cast< wxColour * >(argp2);
29411 if (arg1) (arg1)->colFg = *arg2;
29412
29413 resultobj = SWIG_Py_Void();
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29421 PyObject *resultobj = 0;
29422 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29423 wxColour *result = 0 ;
29424 void *argp1 = 0 ;
29425 int res1 = 0 ;
29426 PyObject *swig_obj[1] ;
29427
29428 if (!args) SWIG_fail;
29429 swig_obj[0] = args;
29430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29431 if (!SWIG_IsOK(res1)) {
29432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29433 }
29434 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29435 result = (wxColour *)& ((arg1)->colFg);
29436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29444 PyObject *resultobj = 0;
29445 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29446 wxColour *arg2 = (wxColour *) 0 ;
29447 void *argp1 = 0 ;
29448 int res1 = 0 ;
29449 void *argp2 = 0 ;
29450 int res2 = 0 ;
29451 PyObject *swig_obj[2] ;
29452
29453 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29455 if (!SWIG_IsOK(res1)) {
29456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29457 }
29458 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29459 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29460 if (!SWIG_IsOK(res2)) {
29461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29462 }
29463 arg2 = reinterpret_cast< wxColour * >(argp2);
29464 if (arg1) (arg1)->colBg = *arg2;
29465
29466 resultobj = SWIG_Py_Void();
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 PyObject *resultobj = 0;
29475 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29476 wxColour *result = 0 ;
29477 void *argp1 = 0 ;
29478 int res1 = 0 ;
29479 PyObject *swig_obj[1] ;
29480
29481 if (!args) SWIG_fail;
29482 swig_obj[0] = args;
29483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29484 if (!SWIG_IsOK(res1)) {
29485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29486 }
29487 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29488 result = (wxColour *)& ((arg1)->colBg);
29489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29497 PyObject *obj;
29498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29499 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29500 return SWIG_Py_Void();
29501 }
29502
29503 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29504 return SWIG_Python_InitShadowInstance(args);
29505 }
29506
29507 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29508 PyObject *resultobj = 0;
29509 wxWindow *arg1 = (wxWindow *) 0 ;
29510 int arg2 = (int) (int)-1 ;
29511 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29512 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29513 wxSize const &arg4_defvalue = wxDefaultSize ;
29514 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29515 long arg5 = (long) 0 ;
29516 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29517 wxString *arg6 = (wxString *) &arg6_defvalue ;
29518 wxWindow *result = 0 ;
29519 void *argp1 = 0 ;
29520 int res1 = 0 ;
29521 int val2 ;
29522 int ecode2 = 0 ;
29523 wxPoint temp3 ;
29524 wxSize temp4 ;
29525 long val5 ;
29526 int ecode5 = 0 ;
29527 bool temp6 = false ;
29528 PyObject * obj0 = 0 ;
29529 PyObject * obj1 = 0 ;
29530 PyObject * obj2 = 0 ;
29531 PyObject * obj3 = 0 ;
29532 PyObject * obj4 = 0 ;
29533 PyObject * obj5 = 0 ;
29534 char * kwnames[] = {
29535 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29536 };
29537
29538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29540 if (!SWIG_IsOK(res1)) {
29541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29542 }
29543 arg1 = reinterpret_cast< wxWindow * >(argp1);
29544 if (obj1) {
29545 ecode2 = SWIG_AsVal_int(obj1, &val2);
29546 if (!SWIG_IsOK(ecode2)) {
29547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29548 }
29549 arg2 = static_cast< int >(val2);
29550 }
29551 if (obj2) {
29552 {
29553 arg3 = &temp3;
29554 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29555 }
29556 }
29557 if (obj3) {
29558 {
29559 arg4 = &temp4;
29560 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29561 }
29562 }
29563 if (obj4) {
29564 ecode5 = SWIG_AsVal_long(obj4, &val5);
29565 if (!SWIG_IsOK(ecode5)) {
29566 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29567 }
29568 arg5 = static_cast< long >(val5);
29569 }
29570 if (obj5) {
29571 {
29572 arg6 = wxString_in_helper(obj5);
29573 if (arg6 == NULL) SWIG_fail;
29574 temp6 = true;
29575 }
29576 }
29577 {
29578 if (!wxPyCheckForApp()) SWIG_fail;
29579 PyThreadState* __tstate = wxPyBeginAllowThreads();
29580 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29581 wxPyEndAllowThreads(__tstate);
29582 if (PyErr_Occurred()) SWIG_fail;
29583 }
29584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29585 {
29586 if (temp6)
29587 delete arg6;
29588 }
29589 return resultobj;
29590 fail:
29591 {
29592 if (temp6)
29593 delete arg6;
29594 }
29595 return NULL;
29596 }
29597
29598
29599 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29600 PyObject *resultobj = 0;
29601 wxWindow *result = 0 ;
29602
29603 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29604 {
29605 if (!wxPyCheckForApp()) SWIG_fail;
29606 PyThreadState* __tstate = wxPyBeginAllowThreads();
29607 result = (wxWindow *)new wxWindow();
29608 wxPyEndAllowThreads(__tstate);
29609 if (PyErr_Occurred()) SWIG_fail;
29610 }
29611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29612 return resultobj;
29613 fail:
29614 return NULL;
29615 }
29616
29617
29618 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29619 PyObject *resultobj = 0;
29620 wxWindow *arg1 = (wxWindow *) 0 ;
29621 wxWindow *arg2 = (wxWindow *) 0 ;
29622 int arg3 = (int) (int)-1 ;
29623 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29624 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29625 wxSize const &arg5_defvalue = wxDefaultSize ;
29626 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29627 long arg6 = (long) 0 ;
29628 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29629 wxString *arg7 = (wxString *) &arg7_defvalue ;
29630 bool result;
29631 void *argp1 = 0 ;
29632 int res1 = 0 ;
29633 void *argp2 = 0 ;
29634 int res2 = 0 ;
29635 int val3 ;
29636 int ecode3 = 0 ;
29637 wxPoint temp4 ;
29638 wxSize temp5 ;
29639 long val6 ;
29640 int ecode6 = 0 ;
29641 bool temp7 = false ;
29642 PyObject * obj0 = 0 ;
29643 PyObject * obj1 = 0 ;
29644 PyObject * obj2 = 0 ;
29645 PyObject * obj3 = 0 ;
29646 PyObject * obj4 = 0 ;
29647 PyObject * obj5 = 0 ;
29648 PyObject * obj6 = 0 ;
29649 char * kwnames[] = {
29650 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29651 };
29652
29653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29655 if (!SWIG_IsOK(res1)) {
29656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29657 }
29658 arg1 = reinterpret_cast< wxWindow * >(argp1);
29659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29660 if (!SWIG_IsOK(res2)) {
29661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29662 }
29663 arg2 = reinterpret_cast< wxWindow * >(argp2);
29664 if (obj2) {
29665 ecode3 = SWIG_AsVal_int(obj2, &val3);
29666 if (!SWIG_IsOK(ecode3)) {
29667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29668 }
29669 arg3 = static_cast< int >(val3);
29670 }
29671 if (obj3) {
29672 {
29673 arg4 = &temp4;
29674 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29675 }
29676 }
29677 if (obj4) {
29678 {
29679 arg5 = &temp5;
29680 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29681 }
29682 }
29683 if (obj5) {
29684 ecode6 = SWIG_AsVal_long(obj5, &val6);
29685 if (!SWIG_IsOK(ecode6)) {
29686 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29687 }
29688 arg6 = static_cast< long >(val6);
29689 }
29690 if (obj6) {
29691 {
29692 arg7 = wxString_in_helper(obj6);
29693 if (arg7 == NULL) SWIG_fail;
29694 temp7 = true;
29695 }
29696 }
29697 {
29698 PyThreadState* __tstate = wxPyBeginAllowThreads();
29699 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29700 wxPyEndAllowThreads(__tstate);
29701 if (PyErr_Occurred()) SWIG_fail;
29702 }
29703 {
29704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29705 }
29706 {
29707 if (temp7)
29708 delete arg7;
29709 }
29710 return resultobj;
29711 fail:
29712 {
29713 if (temp7)
29714 delete arg7;
29715 }
29716 return NULL;
29717 }
29718
29719
29720 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29721 PyObject *resultobj = 0;
29722 wxWindow *arg1 = (wxWindow *) 0 ;
29723 bool arg2 = (bool) false ;
29724 bool result;
29725 void *argp1 = 0 ;
29726 int res1 = 0 ;
29727 bool val2 ;
29728 int ecode2 = 0 ;
29729 PyObject * obj0 = 0 ;
29730 PyObject * obj1 = 0 ;
29731 char * kwnames[] = {
29732 (char *) "self",(char *) "force", NULL
29733 };
29734
29735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29737 if (!SWIG_IsOK(res1)) {
29738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29739 }
29740 arg1 = reinterpret_cast< wxWindow * >(argp1);
29741 if (obj1) {
29742 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29743 if (!SWIG_IsOK(ecode2)) {
29744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29745 }
29746 arg2 = static_cast< bool >(val2);
29747 }
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 result = (bool)(arg1)->Close(arg2);
29751 wxPyEndAllowThreads(__tstate);
29752 if (PyErr_Occurred()) SWIG_fail;
29753 }
29754 {
29755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29756 }
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29764 PyObject *resultobj = 0;
29765 wxWindow *arg1 = (wxWindow *) 0 ;
29766 bool result;
29767 void *argp1 = 0 ;
29768 int res1 = 0 ;
29769 PyObject *swig_obj[1] ;
29770
29771 if (!args) SWIG_fail;
29772 swig_obj[0] = args;
29773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29774 if (!SWIG_IsOK(res1)) {
29775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29776 }
29777 arg1 = reinterpret_cast< wxWindow * >(argp1);
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 result = (bool)(arg1)->Destroy();
29781 wxPyEndAllowThreads(__tstate);
29782 if (PyErr_Occurred()) SWIG_fail;
29783 }
29784 {
29785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29786 }
29787 return resultobj;
29788 fail:
29789 return NULL;
29790 }
29791
29792
29793 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29794 PyObject *resultobj = 0;
29795 wxWindow *arg1 = (wxWindow *) 0 ;
29796 bool result;
29797 void *argp1 = 0 ;
29798 int res1 = 0 ;
29799 PyObject *swig_obj[1] ;
29800
29801 if (!args) SWIG_fail;
29802 swig_obj[0] = args;
29803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29804 if (!SWIG_IsOK(res1)) {
29805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29806 }
29807 arg1 = reinterpret_cast< wxWindow * >(argp1);
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 result = (bool)(arg1)->DestroyChildren();
29811 wxPyEndAllowThreads(__tstate);
29812 if (PyErr_Occurred()) SWIG_fail;
29813 }
29814 {
29815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29816 }
29817 return resultobj;
29818 fail:
29819 return NULL;
29820 }
29821
29822
29823 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29824 PyObject *resultobj = 0;
29825 wxWindow *arg1 = (wxWindow *) 0 ;
29826 bool result;
29827 void *argp1 = 0 ;
29828 int res1 = 0 ;
29829 PyObject *swig_obj[1] ;
29830
29831 if (!args) SWIG_fail;
29832 swig_obj[0] = args;
29833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29834 if (!SWIG_IsOK(res1)) {
29835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29836 }
29837 arg1 = reinterpret_cast< wxWindow * >(argp1);
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 {
29845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29846 }
29847 return resultobj;
29848 fail:
29849 return NULL;
29850 }
29851
29852
29853 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29854 PyObject *resultobj = 0;
29855 wxWindow *arg1 = (wxWindow *) 0 ;
29856 wxString *arg2 = 0 ;
29857 void *argp1 = 0 ;
29858 int res1 = 0 ;
29859 bool temp2 = false ;
29860 PyObject * obj0 = 0 ;
29861 PyObject * obj1 = 0 ;
29862 char * kwnames[] = {
29863 (char *) "self",(char *) "label", NULL
29864 };
29865
29866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29868 if (!SWIG_IsOK(res1)) {
29869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29870 }
29871 arg1 = reinterpret_cast< wxWindow * >(argp1);
29872 {
29873 arg2 = wxString_in_helper(obj1);
29874 if (arg2 == NULL) SWIG_fail;
29875 temp2 = true;
29876 }
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 (arg1)->SetLabel((wxString const &)*arg2);
29880 wxPyEndAllowThreads(__tstate);
29881 if (PyErr_Occurred()) SWIG_fail;
29882 }
29883 resultobj = SWIG_Py_Void();
29884 {
29885 if (temp2)
29886 delete arg2;
29887 }
29888 return resultobj;
29889 fail:
29890 {
29891 if (temp2)
29892 delete arg2;
29893 }
29894 return NULL;
29895 }
29896
29897
29898 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29899 PyObject *resultobj = 0;
29900 wxWindow *arg1 = (wxWindow *) 0 ;
29901 wxString result;
29902 void *argp1 = 0 ;
29903 int res1 = 0 ;
29904 PyObject *swig_obj[1] ;
29905
29906 if (!args) SWIG_fail;
29907 swig_obj[0] = args;
29908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29909 if (!SWIG_IsOK(res1)) {
29910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29911 }
29912 arg1 = reinterpret_cast< wxWindow * >(argp1);
29913 {
29914 PyThreadState* __tstate = wxPyBeginAllowThreads();
29915 result = ((wxWindow const *)arg1)->GetLabel();
29916 wxPyEndAllowThreads(__tstate);
29917 if (PyErr_Occurred()) SWIG_fail;
29918 }
29919 {
29920 #if wxUSE_UNICODE
29921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29922 #else
29923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29924 #endif
29925 }
29926 return resultobj;
29927 fail:
29928 return NULL;
29929 }
29930
29931
29932 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29933 PyObject *resultobj = 0;
29934 wxWindow *arg1 = (wxWindow *) 0 ;
29935 wxString *arg2 = 0 ;
29936 void *argp1 = 0 ;
29937 int res1 = 0 ;
29938 bool temp2 = false ;
29939 PyObject * obj0 = 0 ;
29940 PyObject * obj1 = 0 ;
29941 char * kwnames[] = {
29942 (char *) "self",(char *) "name", NULL
29943 };
29944
29945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29947 if (!SWIG_IsOK(res1)) {
29948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29949 }
29950 arg1 = reinterpret_cast< wxWindow * >(argp1);
29951 {
29952 arg2 = wxString_in_helper(obj1);
29953 if (arg2 == NULL) SWIG_fail;
29954 temp2 = true;
29955 }
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 (arg1)->SetName((wxString const &)*arg2);
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 resultobj = SWIG_Py_Void();
29963 {
29964 if (temp2)
29965 delete arg2;
29966 }
29967 return resultobj;
29968 fail:
29969 {
29970 if (temp2)
29971 delete arg2;
29972 }
29973 return NULL;
29974 }
29975
29976
29977 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29978 PyObject *resultobj = 0;
29979 wxWindow *arg1 = (wxWindow *) 0 ;
29980 wxString result;
29981 void *argp1 = 0 ;
29982 int res1 = 0 ;
29983 PyObject *swig_obj[1] ;
29984
29985 if (!args) SWIG_fail;
29986 swig_obj[0] = args;
29987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29988 if (!SWIG_IsOK(res1)) {
29989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29990 }
29991 arg1 = reinterpret_cast< wxWindow * >(argp1);
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 result = ((wxWindow const *)arg1)->GetName();
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 {
29999 #if wxUSE_UNICODE
30000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30001 #else
30002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30003 #endif
30004 }
30005 return resultobj;
30006 fail:
30007 return NULL;
30008 }
30009
30010
30011 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30012 PyObject *resultobj = 0;
30013 wxWindow *arg1 = (wxWindow *) 0 ;
30014 wxWindowVariant arg2 ;
30015 void *argp1 = 0 ;
30016 int res1 = 0 ;
30017 int val2 ;
30018 int ecode2 = 0 ;
30019 PyObject * obj0 = 0 ;
30020 PyObject * obj1 = 0 ;
30021 char * kwnames[] = {
30022 (char *) "self",(char *) "variant", NULL
30023 };
30024
30025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30027 if (!SWIG_IsOK(res1)) {
30028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30029 }
30030 arg1 = reinterpret_cast< wxWindow * >(argp1);
30031 ecode2 = SWIG_AsVal_int(obj1, &val2);
30032 if (!SWIG_IsOK(ecode2)) {
30033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30034 }
30035 arg2 = static_cast< wxWindowVariant >(val2);
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 (arg1)->SetWindowVariant(arg2);
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 resultobj = SWIG_Py_Void();
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30050 PyObject *resultobj = 0;
30051 wxWindow *arg1 = (wxWindow *) 0 ;
30052 wxWindowVariant result;
30053 void *argp1 = 0 ;
30054 int res1 = 0 ;
30055 PyObject *swig_obj[1] ;
30056
30057 if (!args) SWIG_fail;
30058 swig_obj[0] = args;
30059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30060 if (!SWIG_IsOK(res1)) {
30061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30062 }
30063 arg1 = reinterpret_cast< wxWindow * >(argp1);
30064 {
30065 PyThreadState* __tstate = wxPyBeginAllowThreads();
30066 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 resultobj = SWIG_From_int(static_cast< int >(result));
30071 return resultobj;
30072 fail:
30073 return NULL;
30074 }
30075
30076
30077 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30078 PyObject *resultobj = 0;
30079 wxWindow *arg1 = (wxWindow *) 0 ;
30080 int arg2 ;
30081 void *argp1 = 0 ;
30082 int res1 = 0 ;
30083 int val2 ;
30084 int ecode2 = 0 ;
30085 PyObject * obj0 = 0 ;
30086 PyObject * obj1 = 0 ;
30087 char * kwnames[] = {
30088 (char *) "self",(char *) "winid", NULL
30089 };
30090
30091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30093 if (!SWIG_IsOK(res1)) {
30094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30095 }
30096 arg1 = reinterpret_cast< wxWindow * >(argp1);
30097 ecode2 = SWIG_AsVal_int(obj1, &val2);
30098 if (!SWIG_IsOK(ecode2)) {
30099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30100 }
30101 arg2 = static_cast< int >(val2);
30102 {
30103 PyThreadState* __tstate = wxPyBeginAllowThreads();
30104 (arg1)->SetId(arg2);
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 resultobj = SWIG_Py_Void();
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30116 PyObject *resultobj = 0;
30117 wxWindow *arg1 = (wxWindow *) 0 ;
30118 int result;
30119 void *argp1 = 0 ;
30120 int res1 = 0 ;
30121 PyObject *swig_obj[1] ;
30122
30123 if (!args) SWIG_fail;
30124 swig_obj[0] = args;
30125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30126 if (!SWIG_IsOK(res1)) {
30127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30128 }
30129 arg1 = reinterpret_cast< wxWindow * >(argp1);
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 result = (int)((wxWindow const *)arg1)->GetId();
30133 wxPyEndAllowThreads(__tstate);
30134 if (PyErr_Occurred()) SWIG_fail;
30135 }
30136 resultobj = SWIG_From_int(static_cast< int >(result));
30137 return resultobj;
30138 fail:
30139 return NULL;
30140 }
30141
30142
30143 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30144 PyObject *resultobj = 0;
30145 int result;
30146
30147 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30148 {
30149 PyThreadState* __tstate = wxPyBeginAllowThreads();
30150 result = (int)wxWindow::NewControlId();
30151 wxPyEndAllowThreads(__tstate);
30152 if (PyErr_Occurred()) SWIG_fail;
30153 }
30154 resultobj = SWIG_From_int(static_cast< int >(result));
30155 return resultobj;
30156 fail:
30157 return NULL;
30158 }
30159
30160
30161 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30162 PyObject *resultobj = 0;
30163 int arg1 ;
30164 int result;
30165 int val1 ;
30166 int ecode1 = 0 ;
30167 PyObject * obj0 = 0 ;
30168 char * kwnames[] = {
30169 (char *) "winid", NULL
30170 };
30171
30172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30173 ecode1 = SWIG_AsVal_int(obj0, &val1);
30174 if (!SWIG_IsOK(ecode1)) {
30175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30176 }
30177 arg1 = static_cast< int >(val1);
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 result = (int)wxWindow::NextControlId(arg1);
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 resultobj = SWIG_From_int(static_cast< int >(result));
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj = 0;
30193 int arg1 ;
30194 int result;
30195 int val1 ;
30196 int ecode1 = 0 ;
30197 PyObject * obj0 = 0 ;
30198 char * kwnames[] = {
30199 (char *) "winid", NULL
30200 };
30201
30202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30203 ecode1 = SWIG_AsVal_int(obj0, &val1);
30204 if (!SWIG_IsOK(ecode1)) {
30205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30206 }
30207 arg1 = static_cast< int >(val1);
30208 {
30209 PyThreadState* __tstate = wxPyBeginAllowThreads();
30210 result = (int)wxWindow::PrevControlId(arg1);
30211 wxPyEndAllowThreads(__tstate);
30212 if (PyErr_Occurred()) SWIG_fail;
30213 }
30214 resultobj = SWIG_From_int(static_cast< int >(result));
30215 return resultobj;
30216 fail:
30217 return NULL;
30218 }
30219
30220
30221 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30222 PyObject *resultobj = 0;
30223 wxWindow *arg1 = (wxWindow *) 0 ;
30224 wxSize *arg2 = 0 ;
30225 void *argp1 = 0 ;
30226 int res1 = 0 ;
30227 wxSize temp2 ;
30228 PyObject * obj0 = 0 ;
30229 PyObject * obj1 = 0 ;
30230 char * kwnames[] = {
30231 (char *) "self",(char *) "size", NULL
30232 };
30233
30234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30236 if (!SWIG_IsOK(res1)) {
30237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30238 }
30239 arg1 = reinterpret_cast< wxWindow * >(argp1);
30240 {
30241 arg2 = &temp2;
30242 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30243 }
30244 {
30245 PyThreadState* __tstate = wxPyBeginAllowThreads();
30246 (arg1)->SetSize((wxSize const &)*arg2);
30247 wxPyEndAllowThreads(__tstate);
30248 if (PyErr_Occurred()) SWIG_fail;
30249 }
30250 resultobj = SWIG_Py_Void();
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30258 PyObject *resultobj = 0;
30259 wxWindow *arg1 = (wxWindow *) 0 ;
30260 int arg2 ;
30261 int arg3 ;
30262 int arg4 ;
30263 int arg5 ;
30264 int arg6 = (int) wxSIZE_AUTO ;
30265 void *argp1 = 0 ;
30266 int res1 = 0 ;
30267 int val2 ;
30268 int ecode2 = 0 ;
30269 int val3 ;
30270 int ecode3 = 0 ;
30271 int val4 ;
30272 int ecode4 = 0 ;
30273 int val5 ;
30274 int ecode5 = 0 ;
30275 int val6 ;
30276 int ecode6 = 0 ;
30277 PyObject * obj0 = 0 ;
30278 PyObject * obj1 = 0 ;
30279 PyObject * obj2 = 0 ;
30280 PyObject * obj3 = 0 ;
30281 PyObject * obj4 = 0 ;
30282 PyObject * obj5 = 0 ;
30283 char * kwnames[] = {
30284 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30285 };
30286
30287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30289 if (!SWIG_IsOK(res1)) {
30290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30291 }
30292 arg1 = reinterpret_cast< wxWindow * >(argp1);
30293 ecode2 = SWIG_AsVal_int(obj1, &val2);
30294 if (!SWIG_IsOK(ecode2)) {
30295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30296 }
30297 arg2 = static_cast< int >(val2);
30298 ecode3 = SWIG_AsVal_int(obj2, &val3);
30299 if (!SWIG_IsOK(ecode3)) {
30300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30301 }
30302 arg3 = static_cast< int >(val3);
30303 ecode4 = SWIG_AsVal_int(obj3, &val4);
30304 if (!SWIG_IsOK(ecode4)) {
30305 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30306 }
30307 arg4 = static_cast< int >(val4);
30308 ecode5 = SWIG_AsVal_int(obj4, &val5);
30309 if (!SWIG_IsOK(ecode5)) {
30310 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30311 }
30312 arg5 = static_cast< int >(val5);
30313 if (obj5) {
30314 ecode6 = SWIG_AsVal_int(obj5, &val6);
30315 if (!SWIG_IsOK(ecode6)) {
30316 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30317 }
30318 arg6 = static_cast< int >(val6);
30319 }
30320 {
30321 PyThreadState* __tstate = wxPyBeginAllowThreads();
30322 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 resultobj = SWIG_Py_Void();
30327 return resultobj;
30328 fail:
30329 return NULL;
30330 }
30331
30332
30333 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30334 PyObject *resultobj = 0;
30335 wxWindow *arg1 = (wxWindow *) 0 ;
30336 wxRect *arg2 = 0 ;
30337 int arg3 = (int) wxSIZE_AUTO ;
30338 void *argp1 = 0 ;
30339 int res1 = 0 ;
30340 wxRect temp2 ;
30341 int val3 ;
30342 int ecode3 = 0 ;
30343 PyObject * obj0 = 0 ;
30344 PyObject * obj1 = 0 ;
30345 PyObject * obj2 = 0 ;
30346 char * kwnames[] = {
30347 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30348 };
30349
30350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30352 if (!SWIG_IsOK(res1)) {
30353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30354 }
30355 arg1 = reinterpret_cast< wxWindow * >(argp1);
30356 {
30357 arg2 = &temp2;
30358 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30359 }
30360 if (obj2) {
30361 ecode3 = SWIG_AsVal_int(obj2, &val3);
30362 if (!SWIG_IsOK(ecode3)) {
30363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30364 }
30365 arg3 = static_cast< int >(val3);
30366 }
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 resultobj = SWIG_Py_Void();
30374 return resultobj;
30375 fail:
30376 return NULL;
30377 }
30378
30379
30380 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30381 PyObject *resultobj = 0;
30382 wxWindow *arg1 = (wxWindow *) 0 ;
30383 int arg2 ;
30384 int arg3 ;
30385 void *argp1 = 0 ;
30386 int res1 = 0 ;
30387 int val2 ;
30388 int ecode2 = 0 ;
30389 int val3 ;
30390 int ecode3 = 0 ;
30391 PyObject * obj0 = 0 ;
30392 PyObject * obj1 = 0 ;
30393 PyObject * obj2 = 0 ;
30394 char * kwnames[] = {
30395 (char *) "self",(char *) "width",(char *) "height", NULL
30396 };
30397
30398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30400 if (!SWIG_IsOK(res1)) {
30401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30402 }
30403 arg1 = reinterpret_cast< wxWindow * >(argp1);
30404 ecode2 = SWIG_AsVal_int(obj1, &val2);
30405 if (!SWIG_IsOK(ecode2)) {
30406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30407 }
30408 arg2 = static_cast< int >(val2);
30409 ecode3 = SWIG_AsVal_int(obj2, &val3);
30410 if (!SWIG_IsOK(ecode3)) {
30411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30412 }
30413 arg3 = static_cast< int >(val3);
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 (arg1)->SetSize(arg2,arg3);
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 resultobj = SWIG_Py_Void();
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30428 PyObject *resultobj = 0;
30429 wxWindow *arg1 = (wxWindow *) 0 ;
30430 wxPoint *arg2 = 0 ;
30431 int arg3 = (int) wxSIZE_USE_EXISTING ;
30432 void *argp1 = 0 ;
30433 int res1 = 0 ;
30434 wxPoint temp2 ;
30435 int val3 ;
30436 int ecode3 = 0 ;
30437 PyObject * obj0 = 0 ;
30438 PyObject * obj1 = 0 ;
30439 PyObject * obj2 = 0 ;
30440 char * kwnames[] = {
30441 (char *) "self",(char *) "pt",(char *) "flags", NULL
30442 };
30443
30444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30446 if (!SWIG_IsOK(res1)) {
30447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30448 }
30449 arg1 = reinterpret_cast< wxWindow * >(argp1);
30450 {
30451 arg2 = &temp2;
30452 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30453 }
30454 if (obj2) {
30455 ecode3 = SWIG_AsVal_int(obj2, &val3);
30456 if (!SWIG_IsOK(ecode3)) {
30457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30458 }
30459 arg3 = static_cast< int >(val3);
30460 }
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 (arg1)->Move((wxPoint const &)*arg2,arg3);
30464 wxPyEndAllowThreads(__tstate);
30465 if (PyErr_Occurred()) SWIG_fail;
30466 }
30467 resultobj = SWIG_Py_Void();
30468 return resultobj;
30469 fail:
30470 return NULL;
30471 }
30472
30473
30474 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30475 PyObject *resultobj = 0;
30476 wxWindow *arg1 = (wxWindow *) 0 ;
30477 int arg2 ;
30478 int arg3 ;
30479 int arg4 = (int) wxSIZE_USE_EXISTING ;
30480 void *argp1 = 0 ;
30481 int res1 = 0 ;
30482 int val2 ;
30483 int ecode2 = 0 ;
30484 int val3 ;
30485 int ecode3 = 0 ;
30486 int val4 ;
30487 int ecode4 = 0 ;
30488 PyObject * obj0 = 0 ;
30489 PyObject * obj1 = 0 ;
30490 PyObject * obj2 = 0 ;
30491 PyObject * obj3 = 0 ;
30492 char * kwnames[] = {
30493 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30494 };
30495
30496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30498 if (!SWIG_IsOK(res1)) {
30499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30500 }
30501 arg1 = reinterpret_cast< wxWindow * >(argp1);
30502 ecode2 = SWIG_AsVal_int(obj1, &val2);
30503 if (!SWIG_IsOK(ecode2)) {
30504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30505 }
30506 arg2 = static_cast< int >(val2);
30507 ecode3 = SWIG_AsVal_int(obj2, &val3);
30508 if (!SWIG_IsOK(ecode3)) {
30509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30510 }
30511 arg3 = static_cast< int >(val3);
30512 if (obj3) {
30513 ecode4 = SWIG_AsVal_int(obj3, &val4);
30514 if (!SWIG_IsOK(ecode4)) {
30515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30516 }
30517 arg4 = static_cast< int >(val4);
30518 }
30519 {
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 (arg1)->Move(arg2,arg3,arg4);
30522 wxPyEndAllowThreads(__tstate);
30523 if (PyErr_Occurred()) SWIG_fail;
30524 }
30525 resultobj = SWIG_Py_Void();
30526 return resultobj;
30527 fail:
30528 return NULL;
30529 }
30530
30531
30532 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30533 PyObject *resultobj = 0;
30534 wxWindow *arg1 = (wxWindow *) 0 ;
30535 wxSize const &arg2_defvalue = wxDefaultSize ;
30536 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30537 void *argp1 = 0 ;
30538 int res1 = 0 ;
30539 wxSize temp2 ;
30540 PyObject * obj0 = 0 ;
30541 PyObject * obj1 = 0 ;
30542 char * kwnames[] = {
30543 (char *) "self",(char *) "size", NULL
30544 };
30545
30546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30548 if (!SWIG_IsOK(res1)) {
30549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30550 }
30551 arg1 = reinterpret_cast< wxWindow * >(argp1);
30552 if (obj1) {
30553 {
30554 arg2 = &temp2;
30555 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30556 }
30557 }
30558 {
30559 PyThreadState* __tstate = wxPyBeginAllowThreads();
30560 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30561 wxPyEndAllowThreads(__tstate);
30562 if (PyErr_Occurred()) SWIG_fail;
30563 }
30564 resultobj = SWIG_Py_Void();
30565 return resultobj;
30566 fail:
30567 return NULL;
30568 }
30569
30570
30571 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30572 PyObject *resultobj = 0;
30573 wxWindow *arg1 = (wxWindow *) 0 ;
30574 void *argp1 = 0 ;
30575 int res1 = 0 ;
30576 PyObject *swig_obj[1] ;
30577
30578 if (!args) SWIG_fail;
30579 swig_obj[0] = args;
30580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30581 if (!SWIG_IsOK(res1)) {
30582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30583 }
30584 arg1 = reinterpret_cast< wxWindow * >(argp1);
30585 {
30586 PyThreadState* __tstate = wxPyBeginAllowThreads();
30587 (arg1)->Raise();
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 resultobj = SWIG_Py_Void();
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30599 PyObject *resultobj = 0;
30600 wxWindow *arg1 = (wxWindow *) 0 ;
30601 void *argp1 = 0 ;
30602 int res1 = 0 ;
30603 PyObject *swig_obj[1] ;
30604
30605 if (!args) SWIG_fail;
30606 swig_obj[0] = args;
30607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30608 if (!SWIG_IsOK(res1)) {
30609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30610 }
30611 arg1 = reinterpret_cast< wxWindow * >(argp1);
30612 {
30613 PyThreadState* __tstate = wxPyBeginAllowThreads();
30614 (arg1)->Lower();
30615 wxPyEndAllowThreads(__tstate);
30616 if (PyErr_Occurred()) SWIG_fail;
30617 }
30618 resultobj = SWIG_Py_Void();
30619 return resultobj;
30620 fail:
30621 return NULL;
30622 }
30623
30624
30625 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30626 PyObject *resultobj = 0;
30627 wxWindow *arg1 = (wxWindow *) 0 ;
30628 wxSize *arg2 = 0 ;
30629 void *argp1 = 0 ;
30630 int res1 = 0 ;
30631 wxSize temp2 ;
30632 PyObject * obj0 = 0 ;
30633 PyObject * obj1 = 0 ;
30634 char * kwnames[] = {
30635 (char *) "self",(char *) "size", NULL
30636 };
30637
30638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30640 if (!SWIG_IsOK(res1)) {
30641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30642 }
30643 arg1 = reinterpret_cast< wxWindow * >(argp1);
30644 {
30645 arg2 = &temp2;
30646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30647 }
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 (arg1)->SetClientSize((wxSize const &)*arg2);
30651 wxPyEndAllowThreads(__tstate);
30652 if (PyErr_Occurred()) SWIG_fail;
30653 }
30654 resultobj = SWIG_Py_Void();
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30662 PyObject *resultobj = 0;
30663 wxWindow *arg1 = (wxWindow *) 0 ;
30664 int arg2 ;
30665 int arg3 ;
30666 void *argp1 = 0 ;
30667 int res1 = 0 ;
30668 int val2 ;
30669 int ecode2 = 0 ;
30670 int val3 ;
30671 int ecode3 = 0 ;
30672 PyObject * obj0 = 0 ;
30673 PyObject * obj1 = 0 ;
30674 PyObject * obj2 = 0 ;
30675 char * kwnames[] = {
30676 (char *) "self",(char *) "width",(char *) "height", NULL
30677 };
30678
30679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30681 if (!SWIG_IsOK(res1)) {
30682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30683 }
30684 arg1 = reinterpret_cast< wxWindow * >(argp1);
30685 ecode2 = SWIG_AsVal_int(obj1, &val2);
30686 if (!SWIG_IsOK(ecode2)) {
30687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30688 }
30689 arg2 = static_cast< int >(val2);
30690 ecode3 = SWIG_AsVal_int(obj2, &val3);
30691 if (!SWIG_IsOK(ecode3)) {
30692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30693 }
30694 arg3 = static_cast< int >(val3);
30695 {
30696 PyThreadState* __tstate = wxPyBeginAllowThreads();
30697 (arg1)->SetClientSize(arg2,arg3);
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 resultobj = SWIG_Py_Void();
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj = 0;
30710 wxWindow *arg1 = (wxWindow *) 0 ;
30711 wxRect *arg2 = 0 ;
30712 void *argp1 = 0 ;
30713 int res1 = 0 ;
30714 wxRect temp2 ;
30715 PyObject * obj0 = 0 ;
30716 PyObject * obj1 = 0 ;
30717 char * kwnames[] = {
30718 (char *) "self",(char *) "rect", NULL
30719 };
30720
30721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30723 if (!SWIG_IsOK(res1)) {
30724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30725 }
30726 arg1 = reinterpret_cast< wxWindow * >(argp1);
30727 {
30728 arg2 = &temp2;
30729 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30730 }
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 (arg1)->SetClientSize((wxRect const &)*arg2);
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 resultobj = SWIG_Py_Void();
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30745 PyObject *resultobj = 0;
30746 wxWindow *arg1 = (wxWindow *) 0 ;
30747 wxPoint result;
30748 void *argp1 = 0 ;
30749 int res1 = 0 ;
30750 PyObject *swig_obj[1] ;
30751
30752 if (!args) SWIG_fail;
30753 swig_obj[0] = args;
30754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30755 if (!SWIG_IsOK(res1)) {
30756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30757 }
30758 arg1 = reinterpret_cast< wxWindow * >(argp1);
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 result = ((wxWindow const *)arg1)->GetPosition();
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30773 PyObject *resultobj = 0;
30774 wxWindow *arg1 = (wxWindow *) 0 ;
30775 int *arg2 = (int *) 0 ;
30776 int *arg3 = (int *) 0 ;
30777 void *argp1 = 0 ;
30778 int res1 = 0 ;
30779 int temp2 ;
30780 int res2 = SWIG_TMPOBJ ;
30781 int temp3 ;
30782 int res3 = SWIG_TMPOBJ ;
30783 PyObject *swig_obj[1] ;
30784
30785 arg2 = &temp2;
30786 arg3 = &temp3;
30787 if (!args) SWIG_fail;
30788 swig_obj[0] = args;
30789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30790 if (!SWIG_IsOK(res1)) {
30791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30792 }
30793 arg1 = reinterpret_cast< wxWindow * >(argp1);
30794 {
30795 PyThreadState* __tstate = wxPyBeginAllowThreads();
30796 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30797 wxPyEndAllowThreads(__tstate);
30798 if (PyErr_Occurred()) SWIG_fail;
30799 }
30800 resultobj = SWIG_Py_Void();
30801 if (SWIG_IsTmpObj(res2)) {
30802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30803 } else {
30804 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30806 }
30807 if (SWIG_IsTmpObj(res3)) {
30808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30809 } else {
30810 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30812 }
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30820 PyObject *resultobj = 0;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 wxPoint result;
30823 void *argp1 = 0 ;
30824 int res1 = 0 ;
30825 PyObject *swig_obj[1] ;
30826
30827 if (!args) SWIG_fail;
30828 swig_obj[0] = args;
30829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30832 }
30833 arg1 = reinterpret_cast< wxWindow * >(argp1);
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = ((wxWindow const *)arg1)->GetScreenPosition();
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30841 return resultobj;
30842 fail:
30843 return NULL;
30844 }
30845
30846
30847 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30848 PyObject *resultobj = 0;
30849 wxWindow *arg1 = (wxWindow *) 0 ;
30850 int *arg2 = (int *) 0 ;
30851 int *arg3 = (int *) 0 ;
30852 void *argp1 = 0 ;
30853 int res1 = 0 ;
30854 int temp2 ;
30855 int res2 = SWIG_TMPOBJ ;
30856 int temp3 ;
30857 int res3 = SWIG_TMPOBJ ;
30858 PyObject *swig_obj[1] ;
30859
30860 arg2 = &temp2;
30861 arg3 = &temp3;
30862 if (!args) SWIG_fail;
30863 swig_obj[0] = args;
30864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30865 if (!SWIG_IsOK(res1)) {
30866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30867 }
30868 arg1 = reinterpret_cast< wxWindow * >(argp1);
30869 {
30870 PyThreadState* __tstate = wxPyBeginAllowThreads();
30871 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 resultobj = SWIG_Py_Void();
30876 if (SWIG_IsTmpObj(res2)) {
30877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30878 } else {
30879 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30881 }
30882 if (SWIG_IsTmpObj(res3)) {
30883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30884 } else {
30885 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30887 }
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 wxRect result;
30898 void *argp1 = 0 ;
30899 int res1 = 0 ;
30900 PyObject *swig_obj[1] ;
30901
30902 if (!args) SWIG_fail;
30903 swig_obj[0] = args;
30904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30907 }
30908 arg1 = reinterpret_cast< wxWindow * >(argp1);
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = ((wxWindow const *)arg1)->GetScreenRect();
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30916 return resultobj;
30917 fail:
30918 return NULL;
30919 }
30920
30921
30922 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30923 PyObject *resultobj = 0;
30924 wxWindow *arg1 = (wxWindow *) 0 ;
30925 wxSize result;
30926 void *argp1 = 0 ;
30927 int res1 = 0 ;
30928 PyObject *swig_obj[1] ;
30929
30930 if (!args) SWIG_fail;
30931 swig_obj[0] = args;
30932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30933 if (!SWIG_IsOK(res1)) {
30934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30935 }
30936 arg1 = reinterpret_cast< wxWindow * >(argp1);
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = ((wxWindow const *)arg1)->GetSize();
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30944 return resultobj;
30945 fail:
30946 return NULL;
30947 }
30948
30949
30950 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30951 PyObject *resultobj = 0;
30952 wxWindow *arg1 = (wxWindow *) 0 ;
30953 int *arg2 = (int *) 0 ;
30954 int *arg3 = (int *) 0 ;
30955 void *argp1 = 0 ;
30956 int res1 = 0 ;
30957 int temp2 ;
30958 int res2 = SWIG_TMPOBJ ;
30959 int temp3 ;
30960 int res3 = SWIG_TMPOBJ ;
30961 PyObject *swig_obj[1] ;
30962
30963 arg2 = &temp2;
30964 arg3 = &temp3;
30965 if (!args) SWIG_fail;
30966 swig_obj[0] = args;
30967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30970 }
30971 arg1 = reinterpret_cast< wxWindow * >(argp1);
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_Py_Void();
30979 if (SWIG_IsTmpObj(res2)) {
30980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30981 } else {
30982 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30984 }
30985 if (SWIG_IsTmpObj(res3)) {
30986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30987 } else {
30988 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30990 }
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30998 PyObject *resultobj = 0;
30999 wxWindow *arg1 = (wxWindow *) 0 ;
31000 wxRect result;
31001 void *argp1 = 0 ;
31002 int res1 = 0 ;
31003 PyObject *swig_obj[1] ;
31004
31005 if (!args) SWIG_fail;
31006 swig_obj[0] = args;
31007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31008 if (!SWIG_IsOK(res1)) {
31009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31010 }
31011 arg1 = reinterpret_cast< wxWindow * >(argp1);
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 result = ((wxWindow const *)arg1)->GetRect();
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31026 PyObject *resultobj = 0;
31027 wxWindow *arg1 = (wxWindow *) 0 ;
31028 wxSize result;
31029 void *argp1 = 0 ;
31030 int res1 = 0 ;
31031 PyObject *swig_obj[1] ;
31032
31033 if (!args) SWIG_fail;
31034 swig_obj[0] = args;
31035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31036 if (!SWIG_IsOK(res1)) {
31037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31038 }
31039 arg1 = reinterpret_cast< wxWindow * >(argp1);
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 result = ((wxWindow const *)arg1)->GetClientSize();
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31054 PyObject *resultobj = 0;
31055 wxWindow *arg1 = (wxWindow *) 0 ;
31056 int *arg2 = (int *) 0 ;
31057 int *arg3 = (int *) 0 ;
31058 void *argp1 = 0 ;
31059 int res1 = 0 ;
31060 int temp2 ;
31061 int res2 = SWIG_TMPOBJ ;
31062 int temp3 ;
31063 int res3 = SWIG_TMPOBJ ;
31064 PyObject *swig_obj[1] ;
31065
31066 arg2 = &temp2;
31067 arg3 = &temp3;
31068 if (!args) SWIG_fail;
31069 swig_obj[0] = args;
31070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31071 if (!SWIG_IsOK(res1)) {
31072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31073 }
31074 arg1 = reinterpret_cast< wxWindow * >(argp1);
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31078 wxPyEndAllowThreads(__tstate);
31079 if (PyErr_Occurred()) SWIG_fail;
31080 }
31081 resultobj = SWIG_Py_Void();
31082 if (SWIG_IsTmpObj(res2)) {
31083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31084 } else {
31085 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31087 }
31088 if (SWIG_IsTmpObj(res3)) {
31089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31090 } else {
31091 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31093 }
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31101 PyObject *resultobj = 0;
31102 wxWindow *arg1 = (wxWindow *) 0 ;
31103 wxPoint result;
31104 void *argp1 = 0 ;
31105 int res1 = 0 ;
31106 PyObject *swig_obj[1] ;
31107
31108 if (!args) SWIG_fail;
31109 swig_obj[0] = args;
31110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31111 if (!SWIG_IsOK(res1)) {
31112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31113 }
31114 arg1 = reinterpret_cast< wxWindow * >(argp1);
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31122 return resultobj;
31123 fail:
31124 return NULL;
31125 }
31126
31127
31128 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31129 PyObject *resultobj = 0;
31130 wxWindow *arg1 = (wxWindow *) 0 ;
31131 wxRect result;
31132 void *argp1 = 0 ;
31133 int res1 = 0 ;
31134 PyObject *swig_obj[1] ;
31135
31136 if (!args) SWIG_fail;
31137 swig_obj[0] = args;
31138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31139 if (!SWIG_IsOK(res1)) {
31140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31141 }
31142 arg1 = reinterpret_cast< wxWindow * >(argp1);
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 result = ((wxWindow const *)arg1)->GetClientRect();
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31157 PyObject *resultobj = 0;
31158 wxWindow *arg1 = (wxWindow *) 0 ;
31159 wxSize result;
31160 void *argp1 = 0 ;
31161 int res1 = 0 ;
31162 PyObject *swig_obj[1] ;
31163
31164 if (!args) SWIG_fail;
31165 swig_obj[0] = args;
31166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31167 if (!SWIG_IsOK(res1)) {
31168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31169 }
31170 arg1 = reinterpret_cast< wxWindow * >(argp1);
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 result = ((wxWindow const *)arg1)->GetBestSize();
31174 wxPyEndAllowThreads(__tstate);
31175 if (PyErr_Occurred()) SWIG_fail;
31176 }
31177 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31178 return resultobj;
31179 fail:
31180 return NULL;
31181 }
31182
31183
31184 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31185 PyObject *resultobj = 0;
31186 wxWindow *arg1 = (wxWindow *) 0 ;
31187 int *arg2 = (int *) 0 ;
31188 int *arg3 = (int *) 0 ;
31189 void *argp1 = 0 ;
31190 int res1 = 0 ;
31191 int temp2 ;
31192 int res2 = SWIG_TMPOBJ ;
31193 int temp3 ;
31194 int res3 = SWIG_TMPOBJ ;
31195 PyObject *swig_obj[1] ;
31196
31197 arg2 = &temp2;
31198 arg3 = &temp3;
31199 if (!args) SWIG_fail;
31200 swig_obj[0] = args;
31201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31202 if (!SWIG_IsOK(res1)) {
31203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31204 }
31205 arg1 = reinterpret_cast< wxWindow * >(argp1);
31206 {
31207 PyThreadState* __tstate = wxPyBeginAllowThreads();
31208 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 resultobj = SWIG_Py_Void();
31213 if (SWIG_IsTmpObj(res2)) {
31214 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31215 } else {
31216 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31217 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31218 }
31219 if (SWIG_IsTmpObj(res3)) {
31220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31221 } else {
31222 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31224 }
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31232 PyObject *resultobj = 0;
31233 wxWindow *arg1 = (wxWindow *) 0 ;
31234 void *argp1 = 0 ;
31235 int res1 = 0 ;
31236 PyObject *swig_obj[1] ;
31237
31238 if (!args) SWIG_fail;
31239 swig_obj[0] = args;
31240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31241 if (!SWIG_IsOK(res1)) {
31242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31243 }
31244 arg1 = reinterpret_cast< wxWindow * >(argp1);
31245 {
31246 PyThreadState* __tstate = wxPyBeginAllowThreads();
31247 (arg1)->InvalidateBestSize();
31248 wxPyEndAllowThreads(__tstate);
31249 if (PyErr_Occurred()) SWIG_fail;
31250 }
31251 resultobj = SWIG_Py_Void();
31252 return resultobj;
31253 fail:
31254 return NULL;
31255 }
31256
31257
31258 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31259 PyObject *resultobj = 0;
31260 wxWindow *arg1 = (wxWindow *) 0 ;
31261 wxSize *arg2 = 0 ;
31262 void *argp1 = 0 ;
31263 int res1 = 0 ;
31264 wxSize temp2 ;
31265 PyObject * obj0 = 0 ;
31266 PyObject * obj1 = 0 ;
31267 char * kwnames[] = {
31268 (char *) "self",(char *) "size", NULL
31269 };
31270
31271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31273 if (!SWIG_IsOK(res1)) {
31274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31275 }
31276 arg1 = reinterpret_cast< wxWindow * >(argp1);
31277 {
31278 arg2 = &temp2;
31279 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31280 }
31281 {
31282 PyThreadState* __tstate = wxPyBeginAllowThreads();
31283 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31284 wxPyEndAllowThreads(__tstate);
31285 if (PyErr_Occurred()) SWIG_fail;
31286 }
31287 resultobj = SWIG_Py_Void();
31288 return resultobj;
31289 fail:
31290 return NULL;
31291 }
31292
31293
31294 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31295 PyObject *resultobj = 0;
31296 wxWindow *arg1 = (wxWindow *) 0 ;
31297 wxSize result;
31298 void *argp1 = 0 ;
31299 int res1 = 0 ;
31300 PyObject *swig_obj[1] ;
31301
31302 if (!args) SWIG_fail;
31303 swig_obj[0] = args;
31304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31305 if (!SWIG_IsOK(res1)) {
31306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31307 }
31308 arg1 = reinterpret_cast< wxWindow * >(argp1);
31309 {
31310 PyThreadState* __tstate = wxPyBeginAllowThreads();
31311 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31312 wxPyEndAllowThreads(__tstate);
31313 if (PyErr_Occurred()) SWIG_fail;
31314 }
31315 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31316 return resultobj;
31317 fail:
31318 return NULL;
31319 }
31320
31321
31322 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31323 PyObject *resultobj = 0;
31324 wxWindow *arg1 = (wxWindow *) 0 ;
31325 wxSize result;
31326 void *argp1 = 0 ;
31327 int res1 = 0 ;
31328 PyObject *swig_obj[1] ;
31329
31330 if (!args) SWIG_fail;
31331 swig_obj[0] = args;
31332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31333 if (!SWIG_IsOK(res1)) {
31334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31335 }
31336 arg1 = reinterpret_cast< wxWindow * >(argp1);
31337 {
31338 PyThreadState* __tstate = wxPyBeginAllowThreads();
31339 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31340 wxPyEndAllowThreads(__tstate);
31341 if (PyErr_Occurred()) SWIG_fail;
31342 }
31343 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31351 PyObject *resultobj = 0;
31352 wxWindow *arg1 = (wxWindow *) 0 ;
31353 int arg2 = (int) wxBOTH ;
31354 void *argp1 = 0 ;
31355 int res1 = 0 ;
31356 int val2 ;
31357 int ecode2 = 0 ;
31358 PyObject * obj0 = 0 ;
31359 PyObject * obj1 = 0 ;
31360 char * kwnames[] = {
31361 (char *) "self",(char *) "direction", NULL
31362 };
31363
31364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31366 if (!SWIG_IsOK(res1)) {
31367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31368 }
31369 arg1 = reinterpret_cast< wxWindow * >(argp1);
31370 if (obj1) {
31371 ecode2 = SWIG_AsVal_int(obj1, &val2);
31372 if (!SWIG_IsOK(ecode2)) {
31373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31374 }
31375 arg2 = static_cast< int >(val2);
31376 }
31377 {
31378 PyThreadState* __tstate = wxPyBeginAllowThreads();
31379 (arg1)->Center(arg2);
31380 wxPyEndAllowThreads(__tstate);
31381 if (PyErr_Occurred()) SWIG_fail;
31382 }
31383 resultobj = SWIG_Py_Void();
31384 return resultobj;
31385 fail:
31386 return NULL;
31387 }
31388
31389
31390 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31391 PyObject *resultobj = 0;
31392 wxWindow *arg1 = (wxWindow *) 0 ;
31393 int arg2 = (int) wxBOTH ;
31394 void *argp1 = 0 ;
31395 int res1 = 0 ;
31396 int val2 ;
31397 int ecode2 = 0 ;
31398 PyObject * obj0 = 0 ;
31399 PyObject * obj1 = 0 ;
31400 char * kwnames[] = {
31401 (char *) "self",(char *) "dir", NULL
31402 };
31403
31404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31406 if (!SWIG_IsOK(res1)) {
31407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31408 }
31409 arg1 = reinterpret_cast< wxWindow * >(argp1);
31410 if (obj1) {
31411 ecode2 = SWIG_AsVal_int(obj1, &val2);
31412 if (!SWIG_IsOK(ecode2)) {
31413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31414 }
31415 arg2 = static_cast< int >(val2);
31416 }
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 (arg1)->CenterOnParent(arg2);
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 resultobj = SWIG_Py_Void();
31424 return resultobj;
31425 fail:
31426 return NULL;
31427 }
31428
31429
31430 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31431 PyObject *resultobj = 0;
31432 wxWindow *arg1 = (wxWindow *) 0 ;
31433 void *argp1 = 0 ;
31434 int res1 = 0 ;
31435 PyObject *swig_obj[1] ;
31436
31437 if (!args) SWIG_fail;
31438 swig_obj[0] = args;
31439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31440 if (!SWIG_IsOK(res1)) {
31441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31442 }
31443 arg1 = reinterpret_cast< wxWindow * >(argp1);
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 (arg1)->Fit();
31447 wxPyEndAllowThreads(__tstate);
31448 if (PyErr_Occurred()) SWIG_fail;
31449 }
31450 resultobj = SWIG_Py_Void();
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31458 PyObject *resultobj = 0;
31459 wxWindow *arg1 = (wxWindow *) 0 ;
31460 void *argp1 = 0 ;
31461 int res1 = 0 ;
31462 PyObject *swig_obj[1] ;
31463
31464 if (!args) SWIG_fail;
31465 swig_obj[0] = args;
31466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31467 if (!SWIG_IsOK(res1)) {
31468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31469 }
31470 arg1 = reinterpret_cast< wxWindow * >(argp1);
31471 {
31472 PyThreadState* __tstate = wxPyBeginAllowThreads();
31473 (arg1)->FitInside();
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 resultobj = SWIG_Py_Void();
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj = 0;
31486 wxWindow *arg1 = (wxWindow *) 0 ;
31487 int arg2 ;
31488 int arg3 ;
31489 int arg4 = (int) -1 ;
31490 int arg5 = (int) -1 ;
31491 int arg6 = (int) -1 ;
31492 int arg7 = (int) -1 ;
31493 void *argp1 = 0 ;
31494 int res1 = 0 ;
31495 int val2 ;
31496 int ecode2 = 0 ;
31497 int val3 ;
31498 int ecode3 = 0 ;
31499 int val4 ;
31500 int ecode4 = 0 ;
31501 int val5 ;
31502 int ecode5 = 0 ;
31503 int val6 ;
31504 int ecode6 = 0 ;
31505 int val7 ;
31506 int ecode7 = 0 ;
31507 PyObject * obj0 = 0 ;
31508 PyObject * obj1 = 0 ;
31509 PyObject * obj2 = 0 ;
31510 PyObject * obj3 = 0 ;
31511 PyObject * obj4 = 0 ;
31512 PyObject * obj5 = 0 ;
31513 PyObject * obj6 = 0 ;
31514 char * kwnames[] = {
31515 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31516 };
31517
31518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31520 if (!SWIG_IsOK(res1)) {
31521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31522 }
31523 arg1 = reinterpret_cast< wxWindow * >(argp1);
31524 ecode2 = SWIG_AsVal_int(obj1, &val2);
31525 if (!SWIG_IsOK(ecode2)) {
31526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31527 }
31528 arg2 = static_cast< int >(val2);
31529 ecode3 = SWIG_AsVal_int(obj2, &val3);
31530 if (!SWIG_IsOK(ecode3)) {
31531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31532 }
31533 arg3 = static_cast< int >(val3);
31534 if (obj3) {
31535 ecode4 = SWIG_AsVal_int(obj3, &val4);
31536 if (!SWIG_IsOK(ecode4)) {
31537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31538 }
31539 arg4 = static_cast< int >(val4);
31540 }
31541 if (obj4) {
31542 ecode5 = SWIG_AsVal_int(obj4, &val5);
31543 if (!SWIG_IsOK(ecode5)) {
31544 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31545 }
31546 arg5 = static_cast< int >(val5);
31547 }
31548 if (obj5) {
31549 ecode6 = SWIG_AsVal_int(obj5, &val6);
31550 if (!SWIG_IsOK(ecode6)) {
31551 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31552 }
31553 arg6 = static_cast< int >(val6);
31554 }
31555 if (obj6) {
31556 ecode7 = SWIG_AsVal_int(obj6, &val7);
31557 if (!SWIG_IsOK(ecode7)) {
31558 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31559 }
31560 arg7 = static_cast< int >(val7);
31561 }
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31565 wxPyEndAllowThreads(__tstate);
31566 if (PyErr_Occurred()) SWIG_fail;
31567 }
31568 resultobj = SWIG_Py_Void();
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31576 PyObject *resultobj = 0;
31577 wxWindow *arg1 = (wxWindow *) 0 ;
31578 wxSize *arg2 = 0 ;
31579 wxSize const &arg3_defvalue = wxDefaultSize ;
31580 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31581 wxSize const &arg4_defvalue = wxDefaultSize ;
31582 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31583 void *argp1 = 0 ;
31584 int res1 = 0 ;
31585 wxSize temp2 ;
31586 wxSize temp3 ;
31587 wxSize temp4 ;
31588 PyObject * obj0 = 0 ;
31589 PyObject * obj1 = 0 ;
31590 PyObject * obj2 = 0 ;
31591 PyObject * obj3 = 0 ;
31592 char * kwnames[] = {
31593 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31594 };
31595
31596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31598 if (!SWIG_IsOK(res1)) {
31599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31600 }
31601 arg1 = reinterpret_cast< wxWindow * >(argp1);
31602 {
31603 arg2 = &temp2;
31604 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31605 }
31606 if (obj2) {
31607 {
31608 arg3 = &temp3;
31609 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31610 }
31611 }
31612 if (obj3) {
31613 {
31614 arg4 = &temp4;
31615 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31616 }
31617 }
31618 {
31619 PyThreadState* __tstate = wxPyBeginAllowThreads();
31620 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31621 wxPyEndAllowThreads(__tstate);
31622 if (PyErr_Occurred()) SWIG_fail;
31623 }
31624 resultobj = SWIG_Py_Void();
31625 return resultobj;
31626 fail:
31627 return NULL;
31628 }
31629
31630
31631 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31632 PyObject *resultobj = 0;
31633 wxWindow *arg1 = (wxWindow *) 0 ;
31634 int arg2 ;
31635 int arg3 ;
31636 int arg4 = (int) -1 ;
31637 int arg5 = (int) -1 ;
31638 void *argp1 = 0 ;
31639 int res1 = 0 ;
31640 int val2 ;
31641 int ecode2 = 0 ;
31642 int val3 ;
31643 int ecode3 = 0 ;
31644 int val4 ;
31645 int ecode4 = 0 ;
31646 int val5 ;
31647 int ecode5 = 0 ;
31648 PyObject * obj0 = 0 ;
31649 PyObject * obj1 = 0 ;
31650 PyObject * obj2 = 0 ;
31651 PyObject * obj3 = 0 ;
31652 PyObject * obj4 = 0 ;
31653 char * kwnames[] = {
31654 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31655 };
31656
31657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31659 if (!SWIG_IsOK(res1)) {
31660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31661 }
31662 arg1 = reinterpret_cast< wxWindow * >(argp1);
31663 ecode2 = SWIG_AsVal_int(obj1, &val2);
31664 if (!SWIG_IsOK(ecode2)) {
31665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31666 }
31667 arg2 = static_cast< int >(val2);
31668 ecode3 = SWIG_AsVal_int(obj2, &val3);
31669 if (!SWIG_IsOK(ecode3)) {
31670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31671 }
31672 arg3 = static_cast< int >(val3);
31673 if (obj3) {
31674 ecode4 = SWIG_AsVal_int(obj3, &val4);
31675 if (!SWIG_IsOK(ecode4)) {
31676 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31677 }
31678 arg4 = static_cast< int >(val4);
31679 }
31680 if (obj4) {
31681 ecode5 = SWIG_AsVal_int(obj4, &val5);
31682 if (!SWIG_IsOK(ecode5)) {
31683 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31684 }
31685 arg5 = static_cast< int >(val5);
31686 }
31687 {
31688 PyThreadState* __tstate = wxPyBeginAllowThreads();
31689 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31690 wxPyEndAllowThreads(__tstate);
31691 if (PyErr_Occurred()) SWIG_fail;
31692 }
31693 resultobj = SWIG_Py_Void();
31694 return resultobj;
31695 fail:
31696 return NULL;
31697 }
31698
31699
31700 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31701 PyObject *resultobj = 0;
31702 wxWindow *arg1 = (wxWindow *) 0 ;
31703 wxSize *arg2 = 0 ;
31704 wxSize const &arg3_defvalue = wxDefaultSize ;
31705 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31706 void *argp1 = 0 ;
31707 int res1 = 0 ;
31708 wxSize temp2 ;
31709 wxSize temp3 ;
31710 PyObject * obj0 = 0 ;
31711 PyObject * obj1 = 0 ;
31712 PyObject * obj2 = 0 ;
31713 char * kwnames[] = {
31714 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31715 };
31716
31717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31719 if (!SWIG_IsOK(res1)) {
31720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31721 }
31722 arg1 = reinterpret_cast< wxWindow * >(argp1);
31723 {
31724 arg2 = &temp2;
31725 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31726 }
31727 if (obj2) {
31728 {
31729 arg3 = &temp3;
31730 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31731 }
31732 }
31733 {
31734 PyThreadState* __tstate = wxPyBeginAllowThreads();
31735 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31736 wxPyEndAllowThreads(__tstate);
31737 if (PyErr_Occurred()) SWIG_fail;
31738 }
31739 resultobj = SWIG_Py_Void();
31740 return resultobj;
31741 fail:
31742 return NULL;
31743 }
31744
31745
31746 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31747 PyObject *resultobj = 0;
31748 wxWindow *arg1 = (wxWindow *) 0 ;
31749 wxSize result;
31750 void *argp1 = 0 ;
31751 int res1 = 0 ;
31752 PyObject *swig_obj[1] ;
31753
31754 if (!args) SWIG_fail;
31755 swig_obj[0] = args;
31756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31757 if (!SWIG_IsOK(res1)) {
31758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31759 }
31760 arg1 = reinterpret_cast< wxWindow * >(argp1);
31761 {
31762 PyThreadState* __tstate = wxPyBeginAllowThreads();
31763 result = ((wxWindow const *)arg1)->GetMaxSize();
31764 wxPyEndAllowThreads(__tstate);
31765 if (PyErr_Occurred()) SWIG_fail;
31766 }
31767 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31768 return resultobj;
31769 fail:
31770 return NULL;
31771 }
31772
31773
31774 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31775 PyObject *resultobj = 0;
31776 wxWindow *arg1 = (wxWindow *) 0 ;
31777 wxSize result;
31778 void *argp1 = 0 ;
31779 int res1 = 0 ;
31780 PyObject *swig_obj[1] ;
31781
31782 if (!args) SWIG_fail;
31783 swig_obj[0] = args;
31784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31785 if (!SWIG_IsOK(res1)) {
31786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31787 }
31788 arg1 = reinterpret_cast< wxWindow * >(argp1);
31789 {
31790 PyThreadState* __tstate = wxPyBeginAllowThreads();
31791 result = ((wxWindow const *)arg1)->GetMinSize();
31792 wxPyEndAllowThreads(__tstate);
31793 if (PyErr_Occurred()) SWIG_fail;
31794 }
31795 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31796 return resultobj;
31797 fail:
31798 return NULL;
31799 }
31800
31801
31802 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31803 PyObject *resultobj = 0;
31804 wxWindow *arg1 = (wxWindow *) 0 ;
31805 wxSize *arg2 = 0 ;
31806 void *argp1 = 0 ;
31807 int res1 = 0 ;
31808 wxSize temp2 ;
31809 PyObject * obj0 = 0 ;
31810 PyObject * obj1 = 0 ;
31811 char * kwnames[] = {
31812 (char *) "self",(char *) "minSize", NULL
31813 };
31814
31815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31817 if (!SWIG_IsOK(res1)) {
31818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31819 }
31820 arg1 = reinterpret_cast< wxWindow * >(argp1);
31821 {
31822 arg2 = &temp2;
31823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31824 }
31825 {
31826 PyThreadState* __tstate = wxPyBeginAllowThreads();
31827 (arg1)->SetMinSize((wxSize const &)*arg2);
31828 wxPyEndAllowThreads(__tstate);
31829 if (PyErr_Occurred()) SWIG_fail;
31830 }
31831 resultobj = SWIG_Py_Void();
31832 return resultobj;
31833 fail:
31834 return NULL;
31835 }
31836
31837
31838 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31839 PyObject *resultobj = 0;
31840 wxWindow *arg1 = (wxWindow *) 0 ;
31841 wxSize *arg2 = 0 ;
31842 void *argp1 = 0 ;
31843 int res1 = 0 ;
31844 wxSize temp2 ;
31845 PyObject * obj0 = 0 ;
31846 PyObject * obj1 = 0 ;
31847 char * kwnames[] = {
31848 (char *) "self",(char *) "maxSize", NULL
31849 };
31850
31851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31853 if (!SWIG_IsOK(res1)) {
31854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31855 }
31856 arg1 = reinterpret_cast< wxWindow * >(argp1);
31857 {
31858 arg2 = &temp2;
31859 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31860 }
31861 {
31862 PyThreadState* __tstate = wxPyBeginAllowThreads();
31863 (arg1)->SetMaxSize((wxSize const &)*arg2);
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 resultobj = SWIG_Py_Void();
31868 return resultobj;
31869 fail:
31870 return NULL;
31871 }
31872
31873
31874 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31875 PyObject *resultobj = 0;
31876 wxWindow *arg1 = (wxWindow *) 0 ;
31877 int result;
31878 void *argp1 = 0 ;
31879 int res1 = 0 ;
31880 PyObject *swig_obj[1] ;
31881
31882 if (!args) SWIG_fail;
31883 swig_obj[0] = args;
31884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31885 if (!SWIG_IsOK(res1)) {
31886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31887 }
31888 arg1 = reinterpret_cast< wxWindow * >(argp1);
31889 {
31890 PyThreadState* __tstate = wxPyBeginAllowThreads();
31891 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31892 wxPyEndAllowThreads(__tstate);
31893 if (PyErr_Occurred()) SWIG_fail;
31894 }
31895 resultobj = SWIG_From_int(static_cast< int >(result));
31896 return resultobj;
31897 fail:
31898 return NULL;
31899 }
31900
31901
31902 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31903 PyObject *resultobj = 0;
31904 wxWindow *arg1 = (wxWindow *) 0 ;
31905 int result;
31906 void *argp1 = 0 ;
31907 int res1 = 0 ;
31908 PyObject *swig_obj[1] ;
31909
31910 if (!args) SWIG_fail;
31911 swig_obj[0] = args;
31912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31913 if (!SWIG_IsOK(res1)) {
31914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31915 }
31916 arg1 = reinterpret_cast< wxWindow * >(argp1);
31917 {
31918 PyThreadState* __tstate = wxPyBeginAllowThreads();
31919 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31920 wxPyEndAllowThreads(__tstate);
31921 if (PyErr_Occurred()) SWIG_fail;
31922 }
31923 resultobj = SWIG_From_int(static_cast< int >(result));
31924 return resultobj;
31925 fail:
31926 return NULL;
31927 }
31928
31929
31930 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31931 PyObject *resultobj = 0;
31932 wxWindow *arg1 = (wxWindow *) 0 ;
31933 int result;
31934 void *argp1 = 0 ;
31935 int res1 = 0 ;
31936 PyObject *swig_obj[1] ;
31937
31938 if (!args) SWIG_fail;
31939 swig_obj[0] = args;
31940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31941 if (!SWIG_IsOK(res1)) {
31942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31943 }
31944 arg1 = reinterpret_cast< wxWindow * >(argp1);
31945 {
31946 PyThreadState* __tstate = wxPyBeginAllowThreads();
31947 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31948 wxPyEndAllowThreads(__tstate);
31949 if (PyErr_Occurred()) SWIG_fail;
31950 }
31951 resultobj = SWIG_From_int(static_cast< int >(result));
31952 return resultobj;
31953 fail:
31954 return NULL;
31955 }
31956
31957
31958 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31959 PyObject *resultobj = 0;
31960 wxWindow *arg1 = (wxWindow *) 0 ;
31961 int result;
31962 void *argp1 = 0 ;
31963 int res1 = 0 ;
31964 PyObject *swig_obj[1] ;
31965
31966 if (!args) SWIG_fail;
31967 swig_obj[0] = args;
31968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31969 if (!SWIG_IsOK(res1)) {
31970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31971 }
31972 arg1 = reinterpret_cast< wxWindow * >(argp1);
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31976 wxPyEndAllowThreads(__tstate);
31977 if (PyErr_Occurred()) SWIG_fail;
31978 }
31979 resultobj = SWIG_From_int(static_cast< int >(result));
31980 return resultobj;
31981 fail:
31982 return NULL;
31983 }
31984
31985
31986 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31987 PyObject *resultobj = 0;
31988 wxWindow *arg1 = (wxWindow *) 0 ;
31989 wxSize *arg2 = 0 ;
31990 void *argp1 = 0 ;
31991 int res1 = 0 ;
31992 wxSize temp2 ;
31993 PyObject * obj0 = 0 ;
31994 PyObject * obj1 = 0 ;
31995 char * kwnames[] = {
31996 (char *) "self",(char *) "size", NULL
31997 };
31998
31999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32001 if (!SWIG_IsOK(res1)) {
32002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32003 }
32004 arg1 = reinterpret_cast< wxWindow * >(argp1);
32005 {
32006 arg2 = &temp2;
32007 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32008 }
32009 {
32010 PyThreadState* __tstate = wxPyBeginAllowThreads();
32011 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32012 wxPyEndAllowThreads(__tstate);
32013 if (PyErr_Occurred()) SWIG_fail;
32014 }
32015 resultobj = SWIG_Py_Void();
32016 return resultobj;
32017 fail:
32018 return NULL;
32019 }
32020
32021
32022 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32023 PyObject *resultobj = 0;
32024 wxWindow *arg1 = (wxWindow *) 0 ;
32025 int arg2 ;
32026 int arg3 ;
32027 void *argp1 = 0 ;
32028 int res1 = 0 ;
32029 int val2 ;
32030 int ecode2 = 0 ;
32031 int val3 ;
32032 int ecode3 = 0 ;
32033 PyObject * obj0 = 0 ;
32034 PyObject * obj1 = 0 ;
32035 PyObject * obj2 = 0 ;
32036 char * kwnames[] = {
32037 (char *) "self",(char *) "w",(char *) "h", NULL
32038 };
32039
32040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32042 if (!SWIG_IsOK(res1)) {
32043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32044 }
32045 arg1 = reinterpret_cast< wxWindow * >(argp1);
32046 ecode2 = SWIG_AsVal_int(obj1, &val2);
32047 if (!SWIG_IsOK(ecode2)) {
32048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32049 }
32050 arg2 = static_cast< int >(val2);
32051 ecode3 = SWIG_AsVal_int(obj2, &val3);
32052 if (!SWIG_IsOK(ecode3)) {
32053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32054 }
32055 arg3 = static_cast< int >(val3);
32056 {
32057 PyThreadState* __tstate = wxPyBeginAllowThreads();
32058 (arg1)->SetVirtualSize(arg2,arg3);
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 resultobj = SWIG_Py_Void();
32063 return resultobj;
32064 fail:
32065 return NULL;
32066 }
32067
32068
32069 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32070 PyObject *resultobj = 0;
32071 wxWindow *arg1 = (wxWindow *) 0 ;
32072 wxSize result;
32073 void *argp1 = 0 ;
32074 int res1 = 0 ;
32075 PyObject *swig_obj[1] ;
32076
32077 if (!args) SWIG_fail;
32078 swig_obj[0] = args;
32079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32080 if (!SWIG_IsOK(res1)) {
32081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32082 }
32083 arg1 = reinterpret_cast< wxWindow * >(argp1);
32084 {
32085 PyThreadState* __tstate = wxPyBeginAllowThreads();
32086 result = ((wxWindow const *)arg1)->GetVirtualSize();
32087 wxPyEndAllowThreads(__tstate);
32088 if (PyErr_Occurred()) SWIG_fail;
32089 }
32090 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32091 return resultobj;
32092 fail:
32093 return NULL;
32094 }
32095
32096
32097 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32098 PyObject *resultobj = 0;
32099 wxWindow *arg1 = (wxWindow *) 0 ;
32100 int *arg2 = (int *) 0 ;
32101 int *arg3 = (int *) 0 ;
32102 void *argp1 = 0 ;
32103 int res1 = 0 ;
32104 int temp2 ;
32105 int res2 = SWIG_TMPOBJ ;
32106 int temp3 ;
32107 int res3 = SWIG_TMPOBJ ;
32108 PyObject *swig_obj[1] ;
32109
32110 arg2 = &temp2;
32111 arg3 = &temp3;
32112 if (!args) SWIG_fail;
32113 swig_obj[0] = args;
32114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32115 if (!SWIG_IsOK(res1)) {
32116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32117 }
32118 arg1 = reinterpret_cast< wxWindow * >(argp1);
32119 {
32120 PyThreadState* __tstate = wxPyBeginAllowThreads();
32121 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 resultobj = SWIG_Py_Void();
32126 if (SWIG_IsTmpObj(res2)) {
32127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32128 } else {
32129 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32131 }
32132 if (SWIG_IsTmpObj(res3)) {
32133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32134 } else {
32135 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32137 }
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *resultobj = 0;
32146 wxWindow *arg1 = (wxWindow *) 0 ;
32147 wxSize result;
32148 void *argp1 = 0 ;
32149 int res1 = 0 ;
32150 PyObject *swig_obj[1] ;
32151
32152 if (!args) SWIG_fail;
32153 swig_obj[0] = args;
32154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32155 if (!SWIG_IsOK(res1)) {
32156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32157 }
32158 arg1 = reinterpret_cast< wxWindow * >(argp1);
32159 {
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32166 return resultobj;
32167 fail:
32168 return NULL;
32169 }
32170
32171
32172 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32173 PyObject *resultobj = 0;
32174 wxWindow *arg1 = (wxWindow *) 0 ;
32175 bool arg2 = (bool) true ;
32176 bool result;
32177 void *argp1 = 0 ;
32178 int res1 = 0 ;
32179 bool val2 ;
32180 int ecode2 = 0 ;
32181 PyObject * obj0 = 0 ;
32182 PyObject * obj1 = 0 ;
32183 char * kwnames[] = {
32184 (char *) "self",(char *) "show", NULL
32185 };
32186
32187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32189 if (!SWIG_IsOK(res1)) {
32190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32191 }
32192 arg1 = reinterpret_cast< wxWindow * >(argp1);
32193 if (obj1) {
32194 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32195 if (!SWIG_IsOK(ecode2)) {
32196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32197 }
32198 arg2 = static_cast< bool >(val2);
32199 }
32200 {
32201 PyThreadState* __tstate = wxPyBeginAllowThreads();
32202 result = (bool)(arg1)->Show(arg2);
32203 wxPyEndAllowThreads(__tstate);
32204 if (PyErr_Occurred()) SWIG_fail;
32205 }
32206 {
32207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32208 }
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32216 PyObject *resultobj = 0;
32217 wxWindow *arg1 = (wxWindow *) 0 ;
32218 bool result;
32219 void *argp1 = 0 ;
32220 int res1 = 0 ;
32221 PyObject *swig_obj[1] ;
32222
32223 if (!args) SWIG_fail;
32224 swig_obj[0] = args;
32225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32226 if (!SWIG_IsOK(res1)) {
32227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32228 }
32229 arg1 = reinterpret_cast< wxWindow * >(argp1);
32230 {
32231 PyThreadState* __tstate = wxPyBeginAllowThreads();
32232 result = (bool)(arg1)->Hide();
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 {
32237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32238 }
32239 return resultobj;
32240 fail:
32241 return NULL;
32242 }
32243
32244
32245 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32246 PyObject *resultobj = 0;
32247 wxWindow *arg1 = (wxWindow *) 0 ;
32248 bool arg2 = (bool) true ;
32249 bool result;
32250 void *argp1 = 0 ;
32251 int res1 = 0 ;
32252 bool val2 ;
32253 int ecode2 = 0 ;
32254 PyObject * obj0 = 0 ;
32255 PyObject * obj1 = 0 ;
32256 char * kwnames[] = {
32257 (char *) "self",(char *) "enable", NULL
32258 };
32259
32260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32262 if (!SWIG_IsOK(res1)) {
32263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32264 }
32265 arg1 = reinterpret_cast< wxWindow * >(argp1);
32266 if (obj1) {
32267 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32268 if (!SWIG_IsOK(ecode2)) {
32269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32270 }
32271 arg2 = static_cast< bool >(val2);
32272 }
32273 {
32274 PyThreadState* __tstate = wxPyBeginAllowThreads();
32275 result = (bool)(arg1)->Enable(arg2);
32276 wxPyEndAllowThreads(__tstate);
32277 if (PyErr_Occurred()) SWIG_fail;
32278 }
32279 {
32280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32281 }
32282 return resultobj;
32283 fail:
32284 return NULL;
32285 }
32286
32287
32288 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32289 PyObject *resultobj = 0;
32290 wxWindow *arg1 = (wxWindow *) 0 ;
32291 bool result;
32292 void *argp1 = 0 ;
32293 int res1 = 0 ;
32294 PyObject *swig_obj[1] ;
32295
32296 if (!args) SWIG_fail;
32297 swig_obj[0] = args;
32298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32299 if (!SWIG_IsOK(res1)) {
32300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32301 }
32302 arg1 = reinterpret_cast< wxWindow * >(argp1);
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 result = (bool)(arg1)->Disable();
32306 wxPyEndAllowThreads(__tstate);
32307 if (PyErr_Occurred()) SWIG_fail;
32308 }
32309 {
32310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32311 }
32312 return resultobj;
32313 fail:
32314 return NULL;
32315 }
32316
32317
32318 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32319 PyObject *resultobj = 0;
32320 wxWindow *arg1 = (wxWindow *) 0 ;
32321 bool result;
32322 void *argp1 = 0 ;
32323 int res1 = 0 ;
32324 PyObject *swig_obj[1] ;
32325
32326 if (!args) SWIG_fail;
32327 swig_obj[0] = args;
32328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32329 if (!SWIG_IsOK(res1)) {
32330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32331 }
32332 arg1 = reinterpret_cast< wxWindow * >(argp1);
32333 {
32334 PyThreadState* __tstate = wxPyBeginAllowThreads();
32335 result = (bool)((wxWindow const *)arg1)->IsShown();
32336 wxPyEndAllowThreads(__tstate);
32337 if (PyErr_Occurred()) SWIG_fail;
32338 }
32339 {
32340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32341 }
32342 return resultobj;
32343 fail:
32344 return NULL;
32345 }
32346
32347
32348 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32349 PyObject *resultobj = 0;
32350 wxWindow *arg1 = (wxWindow *) 0 ;
32351 bool result;
32352 void *argp1 = 0 ;
32353 int res1 = 0 ;
32354 PyObject *swig_obj[1] ;
32355
32356 if (!args) SWIG_fail;
32357 swig_obj[0] = args;
32358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32359 if (!SWIG_IsOK(res1)) {
32360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32361 }
32362 arg1 = reinterpret_cast< wxWindow * >(argp1);
32363 {
32364 PyThreadState* __tstate = wxPyBeginAllowThreads();
32365 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32366 wxPyEndAllowThreads(__tstate);
32367 if (PyErr_Occurred()) SWIG_fail;
32368 }
32369 {
32370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32371 }
32372 return resultobj;
32373 fail:
32374 return NULL;
32375 }
32376
32377
32378 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32379 PyObject *resultobj = 0;
32380 wxWindow *arg1 = (wxWindow *) 0 ;
32381 long arg2 ;
32382 void *argp1 = 0 ;
32383 int res1 = 0 ;
32384 long val2 ;
32385 int ecode2 = 0 ;
32386 PyObject * obj0 = 0 ;
32387 PyObject * obj1 = 0 ;
32388 char * kwnames[] = {
32389 (char *) "self",(char *) "style", NULL
32390 };
32391
32392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32394 if (!SWIG_IsOK(res1)) {
32395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32396 }
32397 arg1 = reinterpret_cast< wxWindow * >(argp1);
32398 ecode2 = SWIG_AsVal_long(obj1, &val2);
32399 if (!SWIG_IsOK(ecode2)) {
32400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32401 }
32402 arg2 = static_cast< long >(val2);
32403 {
32404 PyThreadState* __tstate = wxPyBeginAllowThreads();
32405 (arg1)->SetWindowStyleFlag(arg2);
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 resultobj = SWIG_Py_Void();
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32417 PyObject *resultobj = 0;
32418 wxWindow *arg1 = (wxWindow *) 0 ;
32419 long result;
32420 void *argp1 = 0 ;
32421 int res1 = 0 ;
32422 PyObject *swig_obj[1] ;
32423
32424 if (!args) SWIG_fail;
32425 swig_obj[0] = args;
32426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32427 if (!SWIG_IsOK(res1)) {
32428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32429 }
32430 arg1 = reinterpret_cast< wxWindow * >(argp1);
32431 {
32432 PyThreadState* __tstate = wxPyBeginAllowThreads();
32433 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32434 wxPyEndAllowThreads(__tstate);
32435 if (PyErr_Occurred()) SWIG_fail;
32436 }
32437 resultobj = SWIG_From_long(static_cast< long >(result));
32438 return resultobj;
32439 fail:
32440 return NULL;
32441 }
32442
32443
32444 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32445 PyObject *resultobj = 0;
32446 wxWindow *arg1 = (wxWindow *) 0 ;
32447 int arg2 ;
32448 bool result;
32449 void *argp1 = 0 ;
32450 int res1 = 0 ;
32451 int val2 ;
32452 int ecode2 = 0 ;
32453 PyObject * obj0 = 0 ;
32454 PyObject * obj1 = 0 ;
32455 char * kwnames[] = {
32456 (char *) "self",(char *) "flag", NULL
32457 };
32458
32459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32461 if (!SWIG_IsOK(res1)) {
32462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32463 }
32464 arg1 = reinterpret_cast< wxWindow * >(argp1);
32465 ecode2 = SWIG_AsVal_int(obj1, &val2);
32466 if (!SWIG_IsOK(ecode2)) {
32467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32468 }
32469 arg2 = static_cast< int >(val2);
32470 {
32471 PyThreadState* __tstate = wxPyBeginAllowThreads();
32472 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 {
32477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32478 }
32479 return resultobj;
32480 fail:
32481 return NULL;
32482 }
32483
32484
32485 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32486 PyObject *resultobj = 0;
32487 wxWindow *arg1 = (wxWindow *) 0 ;
32488 bool result;
32489 void *argp1 = 0 ;
32490 int res1 = 0 ;
32491 PyObject *swig_obj[1] ;
32492
32493 if (!args) SWIG_fail;
32494 swig_obj[0] = args;
32495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32496 if (!SWIG_IsOK(res1)) {
32497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32498 }
32499 arg1 = reinterpret_cast< wxWindow * >(argp1);
32500 {
32501 PyThreadState* __tstate = wxPyBeginAllowThreads();
32502 result = (bool)((wxWindow const *)arg1)->IsRetained();
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 {
32507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32508 }
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32516 PyObject *resultobj = 0;
32517 wxWindow *arg1 = (wxWindow *) 0 ;
32518 long arg2 ;
32519 void *argp1 = 0 ;
32520 int res1 = 0 ;
32521 long val2 ;
32522 int ecode2 = 0 ;
32523 PyObject * obj0 = 0 ;
32524 PyObject * obj1 = 0 ;
32525 char * kwnames[] = {
32526 (char *) "self",(char *) "exStyle", NULL
32527 };
32528
32529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32531 if (!SWIG_IsOK(res1)) {
32532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32533 }
32534 arg1 = reinterpret_cast< wxWindow * >(argp1);
32535 ecode2 = SWIG_AsVal_long(obj1, &val2);
32536 if (!SWIG_IsOK(ecode2)) {
32537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32538 }
32539 arg2 = static_cast< long >(val2);
32540 {
32541 PyThreadState* __tstate = wxPyBeginAllowThreads();
32542 (arg1)->SetExtraStyle(arg2);
32543 wxPyEndAllowThreads(__tstate);
32544 if (PyErr_Occurred()) SWIG_fail;
32545 }
32546 resultobj = SWIG_Py_Void();
32547 return resultobj;
32548 fail:
32549 return NULL;
32550 }
32551
32552
32553 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32554 PyObject *resultobj = 0;
32555 wxWindow *arg1 = (wxWindow *) 0 ;
32556 long result;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 PyObject *swig_obj[1] ;
32560
32561 if (!args) SWIG_fail;
32562 swig_obj[0] = args;
32563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32564 if (!SWIG_IsOK(res1)) {
32565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32566 }
32567 arg1 = reinterpret_cast< wxWindow * >(argp1);
32568 {
32569 PyThreadState* __tstate = wxPyBeginAllowThreads();
32570 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32571 wxPyEndAllowThreads(__tstate);
32572 if (PyErr_Occurred()) SWIG_fail;
32573 }
32574 resultobj = SWIG_From_long(static_cast< long >(result));
32575 return resultobj;
32576 fail:
32577 return NULL;
32578 }
32579
32580
32581 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32582 PyObject *resultobj = 0;
32583 wxWindow *arg1 = (wxWindow *) 0 ;
32584 bool arg2 = (bool) true ;
32585 void *argp1 = 0 ;
32586 int res1 = 0 ;
32587 bool val2 ;
32588 int ecode2 = 0 ;
32589 PyObject * obj0 = 0 ;
32590 PyObject * obj1 = 0 ;
32591 char * kwnames[] = {
32592 (char *) "self",(char *) "modal", NULL
32593 };
32594
32595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32597 if (!SWIG_IsOK(res1)) {
32598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32599 }
32600 arg1 = reinterpret_cast< wxWindow * >(argp1);
32601 if (obj1) {
32602 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32603 if (!SWIG_IsOK(ecode2)) {
32604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32605 }
32606 arg2 = static_cast< bool >(val2);
32607 }
32608 {
32609 PyThreadState* __tstate = wxPyBeginAllowThreads();
32610 (arg1)->MakeModal(arg2);
32611 wxPyEndAllowThreads(__tstate);
32612 if (PyErr_Occurred()) SWIG_fail;
32613 }
32614 resultobj = SWIG_Py_Void();
32615 return resultobj;
32616 fail:
32617 return NULL;
32618 }
32619
32620
32621 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32622 PyObject *resultobj = 0;
32623 wxWindow *arg1 = (wxWindow *) 0 ;
32624 bool arg2 ;
32625 void *argp1 = 0 ;
32626 int res1 = 0 ;
32627 bool val2 ;
32628 int ecode2 = 0 ;
32629 PyObject * obj0 = 0 ;
32630 PyObject * obj1 = 0 ;
32631 char * kwnames[] = {
32632 (char *) "self",(char *) "enableTheme", NULL
32633 };
32634
32635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32637 if (!SWIG_IsOK(res1)) {
32638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32639 }
32640 arg1 = reinterpret_cast< wxWindow * >(argp1);
32641 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32642 if (!SWIG_IsOK(ecode2)) {
32643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32644 }
32645 arg2 = static_cast< bool >(val2);
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 (arg1)->SetThemeEnabled(arg2);
32649 wxPyEndAllowThreads(__tstate);
32650 if (PyErr_Occurred()) SWIG_fail;
32651 }
32652 resultobj = SWIG_Py_Void();
32653 return resultobj;
32654 fail:
32655 return NULL;
32656 }
32657
32658
32659 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32660 PyObject *resultobj = 0;
32661 wxWindow *arg1 = (wxWindow *) 0 ;
32662 bool result;
32663 void *argp1 = 0 ;
32664 int res1 = 0 ;
32665 PyObject *swig_obj[1] ;
32666
32667 if (!args) SWIG_fail;
32668 swig_obj[0] = args;
32669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32670 if (!SWIG_IsOK(res1)) {
32671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32672 }
32673 arg1 = reinterpret_cast< wxWindow * >(argp1);
32674 {
32675 PyThreadState* __tstate = wxPyBeginAllowThreads();
32676 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32677 wxPyEndAllowThreads(__tstate);
32678 if (PyErr_Occurred()) SWIG_fail;
32679 }
32680 {
32681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32682 }
32683 return resultobj;
32684 fail:
32685 return NULL;
32686 }
32687
32688
32689 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32690 PyObject *resultobj = 0;
32691 wxWindow *arg1 = (wxWindow *) 0 ;
32692 void *argp1 = 0 ;
32693 int res1 = 0 ;
32694 PyObject *swig_obj[1] ;
32695
32696 if (!args) SWIG_fail;
32697 swig_obj[0] = args;
32698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32699 if (!SWIG_IsOK(res1)) {
32700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32701 }
32702 arg1 = reinterpret_cast< wxWindow * >(argp1);
32703 {
32704 PyThreadState* __tstate = wxPyBeginAllowThreads();
32705 (arg1)->SetFocus();
32706 wxPyEndAllowThreads(__tstate);
32707 if (PyErr_Occurred()) SWIG_fail;
32708 }
32709 resultobj = SWIG_Py_Void();
32710 return resultobj;
32711 fail:
32712 return NULL;
32713 }
32714
32715
32716 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32717 PyObject *resultobj = 0;
32718 wxWindow *arg1 = (wxWindow *) 0 ;
32719 void *argp1 = 0 ;
32720 int res1 = 0 ;
32721 PyObject *swig_obj[1] ;
32722
32723 if (!args) SWIG_fail;
32724 swig_obj[0] = args;
32725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32726 if (!SWIG_IsOK(res1)) {
32727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32728 }
32729 arg1 = reinterpret_cast< wxWindow * >(argp1);
32730 {
32731 PyThreadState* __tstate = wxPyBeginAllowThreads();
32732 (arg1)->SetFocusFromKbd();
32733 wxPyEndAllowThreads(__tstate);
32734 if (PyErr_Occurred()) SWIG_fail;
32735 }
32736 resultobj = SWIG_Py_Void();
32737 return resultobj;
32738 fail:
32739 return NULL;
32740 }
32741
32742
32743 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32744 PyObject *resultobj = 0;
32745 wxWindow *result = 0 ;
32746
32747 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32748 {
32749 if (!wxPyCheckForApp()) SWIG_fail;
32750 PyThreadState* __tstate = wxPyBeginAllowThreads();
32751 result = (wxWindow *)wxWindow::FindFocus();
32752 wxPyEndAllowThreads(__tstate);
32753 if (PyErr_Occurred()) SWIG_fail;
32754 }
32755 {
32756 resultobj = wxPyMake_wxObject(result, 0);
32757 }
32758 return resultobj;
32759 fail:
32760 return NULL;
32761 }
32762
32763
32764 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32765 PyObject *resultobj = 0;
32766 wxWindow *arg1 = (wxWindow *) 0 ;
32767 bool result;
32768 void *argp1 = 0 ;
32769 int res1 = 0 ;
32770 PyObject *swig_obj[1] ;
32771
32772 if (!args) SWIG_fail;
32773 swig_obj[0] = args;
32774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32775 if (!SWIG_IsOK(res1)) {
32776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32777 }
32778 arg1 = reinterpret_cast< wxWindow * >(argp1);
32779 {
32780 PyThreadState* __tstate = wxPyBeginAllowThreads();
32781 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32782 wxPyEndAllowThreads(__tstate);
32783 if (PyErr_Occurred()) SWIG_fail;
32784 }
32785 {
32786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32787 }
32788 return resultobj;
32789 fail:
32790 return NULL;
32791 }
32792
32793
32794 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32795 PyObject *resultobj = 0;
32796 wxWindow *arg1 = (wxWindow *) 0 ;
32797 bool result;
32798 void *argp1 = 0 ;
32799 int res1 = 0 ;
32800 PyObject *swig_obj[1] ;
32801
32802 if (!args) SWIG_fail;
32803 swig_obj[0] = args;
32804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32807 }
32808 arg1 = reinterpret_cast< wxWindow * >(argp1);
32809 {
32810 PyThreadState* __tstate = wxPyBeginAllowThreads();
32811 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32812 wxPyEndAllowThreads(__tstate);
32813 if (PyErr_Occurred()) SWIG_fail;
32814 }
32815 {
32816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32817 }
32818 return resultobj;
32819 fail:
32820 return NULL;
32821 }
32822
32823
32824 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32825 PyObject *resultobj = 0;
32826 wxWindow *arg1 = (wxWindow *) 0 ;
32827 wxWindow *result = 0 ;
32828 void *argp1 = 0 ;
32829 int res1 = 0 ;
32830 PyObject *swig_obj[1] ;
32831
32832 if (!args) SWIG_fail;
32833 swig_obj[0] = args;
32834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32835 if (!SWIG_IsOK(res1)) {
32836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32837 }
32838 arg1 = reinterpret_cast< wxWindow * >(argp1);
32839 {
32840 PyThreadState* __tstate = wxPyBeginAllowThreads();
32841 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32842 wxPyEndAllowThreads(__tstate);
32843 if (PyErr_Occurred()) SWIG_fail;
32844 }
32845 {
32846 resultobj = wxPyMake_wxObject(result, 0);
32847 }
32848 return resultobj;
32849 fail:
32850 return NULL;
32851 }
32852
32853
32854 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32855 PyObject *resultobj = 0;
32856 wxWindow *arg1 = (wxWindow *) 0 ;
32857 wxWindow *arg2 = (wxWindow *) 0 ;
32858 wxWindow *result = 0 ;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 void *argp2 = 0 ;
32862 int res2 = 0 ;
32863 PyObject * obj0 = 0 ;
32864 PyObject * obj1 = 0 ;
32865 char * kwnames[] = {
32866 (char *) "self",(char *) "child", NULL
32867 };
32868
32869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32871 if (!SWIG_IsOK(res1)) {
32872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32873 }
32874 arg1 = reinterpret_cast< wxWindow * >(argp1);
32875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32876 if (!SWIG_IsOK(res2)) {
32877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32878 }
32879 arg2 = reinterpret_cast< wxWindow * >(argp2);
32880 {
32881 PyThreadState* __tstate = wxPyBeginAllowThreads();
32882 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32883 wxPyEndAllowThreads(__tstate);
32884 if (PyErr_Occurred()) SWIG_fail;
32885 }
32886 {
32887 resultobj = wxPyMake_wxObject(result, 0);
32888 }
32889 return resultobj;
32890 fail:
32891 return NULL;
32892 }
32893
32894
32895 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32896 PyObject *resultobj = 0;
32897 wxWindow *arg1 = (wxWindow *) 0 ;
32898 wxWindow *arg2 = (wxWindow *) 0 ;
32899 void *argp1 = 0 ;
32900 int res1 = 0 ;
32901 void *argp2 = 0 ;
32902 int res2 = 0 ;
32903 PyObject * obj0 = 0 ;
32904 PyObject * obj1 = 0 ;
32905 char * kwnames[] = {
32906 (char *) "self",(char *) "win", NULL
32907 };
32908
32909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32911 if (!SWIG_IsOK(res1)) {
32912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32913 }
32914 arg1 = reinterpret_cast< wxWindow * >(argp1);
32915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32916 if (!SWIG_IsOK(res2)) {
32917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32918 }
32919 arg2 = reinterpret_cast< wxWindow * >(argp2);
32920 {
32921 PyThreadState* __tstate = wxPyBeginAllowThreads();
32922 (arg1)->SetTmpDefaultItem(arg2);
32923 wxPyEndAllowThreads(__tstate);
32924 if (PyErr_Occurred()) SWIG_fail;
32925 }
32926 resultobj = SWIG_Py_Void();
32927 return resultobj;
32928 fail:
32929 return NULL;
32930 }
32931
32932
32933 SWIGINTERN PyObject *_wrap_Window_GetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32934 PyObject *resultobj = 0;
32935 wxWindow *arg1 = (wxWindow *) 0 ;
32936 wxWindow *result = 0 ;
32937 void *argp1 = 0 ;
32938 int res1 = 0 ;
32939 PyObject *swig_obj[1] ;
32940
32941 if (!args) SWIG_fail;
32942 swig_obj[0] = args;
32943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32944 if (!SWIG_IsOK(res1)) {
32945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32946 }
32947 arg1 = reinterpret_cast< wxWindow * >(argp1);
32948 {
32949 PyThreadState* __tstate = wxPyBeginAllowThreads();
32950 result = (wxWindow *)((wxWindow const *)arg1)->GetTmpDefaultItem();
32951 wxPyEndAllowThreads(__tstate);
32952 if (PyErr_Occurred()) SWIG_fail;
32953 }
32954 {
32955 resultobj = wxPyMake_wxObject(result, 0);
32956 }
32957 return resultobj;
32958 fail:
32959 return NULL;
32960 }
32961
32962
32963 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32964 PyObject *resultobj = 0;
32965 wxWindow *arg1 = (wxWindow *) 0 ;
32966 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32967 bool result;
32968 void *argp1 = 0 ;
32969 int res1 = 0 ;
32970 int val2 ;
32971 int ecode2 = 0 ;
32972 PyObject * obj0 = 0 ;
32973 PyObject * obj1 = 0 ;
32974 char * kwnames[] = {
32975 (char *) "self",(char *) "flags", NULL
32976 };
32977
32978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32980 if (!SWIG_IsOK(res1)) {
32981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32982 }
32983 arg1 = reinterpret_cast< wxWindow * >(argp1);
32984 if (obj1) {
32985 ecode2 = SWIG_AsVal_int(obj1, &val2);
32986 if (!SWIG_IsOK(ecode2)) {
32987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32988 }
32989 arg2 = static_cast< int >(val2);
32990 }
32991 {
32992 PyThreadState* __tstate = wxPyBeginAllowThreads();
32993 result = (bool)(arg1)->Navigate(arg2);
32994 wxPyEndAllowThreads(__tstate);
32995 if (PyErr_Occurred()) SWIG_fail;
32996 }
32997 {
32998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32999 }
33000 return resultobj;
33001 fail:
33002 return NULL;
33003 }
33004
33005
33006 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33007 PyObject *resultobj = 0;
33008 wxWindow *arg1 = (wxWindow *) 0 ;
33009 wxWindow *arg2 = (wxWindow *) 0 ;
33010 void *argp1 = 0 ;
33011 int res1 = 0 ;
33012 void *argp2 = 0 ;
33013 int res2 = 0 ;
33014 PyObject * obj0 = 0 ;
33015 PyObject * obj1 = 0 ;
33016 char * kwnames[] = {
33017 (char *) "self",(char *) "win", NULL
33018 };
33019
33020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33022 if (!SWIG_IsOK(res1)) {
33023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33024 }
33025 arg1 = reinterpret_cast< wxWindow * >(argp1);
33026 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33027 if (!SWIG_IsOK(res2)) {
33028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33029 }
33030 arg2 = reinterpret_cast< wxWindow * >(argp2);
33031 {
33032 PyThreadState* __tstate = wxPyBeginAllowThreads();
33033 (arg1)->MoveAfterInTabOrder(arg2);
33034 wxPyEndAllowThreads(__tstate);
33035 if (PyErr_Occurred()) SWIG_fail;
33036 }
33037 resultobj = SWIG_Py_Void();
33038 return resultobj;
33039 fail:
33040 return NULL;
33041 }
33042
33043
33044 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33045 PyObject *resultobj = 0;
33046 wxWindow *arg1 = (wxWindow *) 0 ;
33047 wxWindow *arg2 = (wxWindow *) 0 ;
33048 void *argp1 = 0 ;
33049 int res1 = 0 ;
33050 void *argp2 = 0 ;
33051 int res2 = 0 ;
33052 PyObject * obj0 = 0 ;
33053 PyObject * obj1 = 0 ;
33054 char * kwnames[] = {
33055 (char *) "self",(char *) "win", NULL
33056 };
33057
33058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33060 if (!SWIG_IsOK(res1)) {
33061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33062 }
33063 arg1 = reinterpret_cast< wxWindow * >(argp1);
33064 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33065 if (!SWIG_IsOK(res2)) {
33066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33067 }
33068 arg2 = reinterpret_cast< wxWindow * >(argp2);
33069 {
33070 PyThreadState* __tstate = wxPyBeginAllowThreads();
33071 (arg1)->MoveBeforeInTabOrder(arg2);
33072 wxPyEndAllowThreads(__tstate);
33073 if (PyErr_Occurred()) SWIG_fail;
33074 }
33075 resultobj = SWIG_Py_Void();
33076 return resultobj;
33077 fail:
33078 return NULL;
33079 }
33080
33081
33082 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33083 PyObject *resultobj = 0;
33084 wxWindow *arg1 = (wxWindow *) 0 ;
33085 PyObject *result = 0 ;
33086 void *argp1 = 0 ;
33087 int res1 = 0 ;
33088 PyObject *swig_obj[1] ;
33089
33090 if (!args) SWIG_fail;
33091 swig_obj[0] = args;
33092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33093 if (!SWIG_IsOK(res1)) {
33094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33095 }
33096 arg1 = reinterpret_cast< wxWindow * >(argp1);
33097 {
33098 PyThreadState* __tstate = wxPyBeginAllowThreads();
33099 result = (PyObject *)wxWindow_GetChildren(arg1);
33100 wxPyEndAllowThreads(__tstate);
33101 if (PyErr_Occurred()) SWIG_fail;
33102 }
33103 resultobj = result;
33104 return resultobj;
33105 fail:
33106 return NULL;
33107 }
33108
33109
33110 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33111 PyObject *resultobj = 0;
33112 wxWindow *arg1 = (wxWindow *) 0 ;
33113 wxWindow *result = 0 ;
33114 void *argp1 = 0 ;
33115 int res1 = 0 ;
33116 PyObject *swig_obj[1] ;
33117
33118 if (!args) SWIG_fail;
33119 swig_obj[0] = args;
33120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33121 if (!SWIG_IsOK(res1)) {
33122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33123 }
33124 arg1 = reinterpret_cast< wxWindow * >(argp1);
33125 {
33126 PyThreadState* __tstate = wxPyBeginAllowThreads();
33127 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33128 wxPyEndAllowThreads(__tstate);
33129 if (PyErr_Occurred()) SWIG_fail;
33130 }
33131 {
33132 resultobj = wxPyMake_wxObject(result, 0);
33133 }
33134 return resultobj;
33135 fail:
33136 return NULL;
33137 }
33138
33139
33140 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33141 PyObject *resultobj = 0;
33142 wxWindow *arg1 = (wxWindow *) 0 ;
33143 wxWindow *result = 0 ;
33144 void *argp1 = 0 ;
33145 int res1 = 0 ;
33146 PyObject *swig_obj[1] ;
33147
33148 if (!args) SWIG_fail;
33149 swig_obj[0] = args;
33150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33151 if (!SWIG_IsOK(res1)) {
33152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33153 }
33154 arg1 = reinterpret_cast< wxWindow * >(argp1);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 {
33162 resultobj = wxPyMake_wxObject(result, 0);
33163 }
33164 return resultobj;
33165 fail:
33166 return NULL;
33167 }
33168
33169
33170 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33171 PyObject *resultobj = 0;
33172 wxWindow *arg1 = (wxWindow *) 0 ;
33173 bool result;
33174 void *argp1 = 0 ;
33175 int res1 = 0 ;
33176 PyObject *swig_obj[1] ;
33177
33178 if (!args) SWIG_fail;
33179 swig_obj[0] = args;
33180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33181 if (!SWIG_IsOK(res1)) {
33182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33183 }
33184 arg1 = reinterpret_cast< wxWindow * >(argp1);
33185 {
33186 PyThreadState* __tstate = wxPyBeginAllowThreads();
33187 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33188 wxPyEndAllowThreads(__tstate);
33189 if (PyErr_Occurred()) SWIG_fail;
33190 }
33191 {
33192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33193 }
33194 return resultobj;
33195 fail:
33196 return NULL;
33197 }
33198
33199
33200 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33201 PyObject *resultobj = 0;
33202 wxWindow *arg1 = (wxWindow *) 0 ;
33203 wxWindow *arg2 = (wxWindow *) 0 ;
33204 bool result;
33205 void *argp1 = 0 ;
33206 int res1 = 0 ;
33207 void *argp2 = 0 ;
33208 int res2 = 0 ;
33209 PyObject * obj0 = 0 ;
33210 PyObject * obj1 = 0 ;
33211 char * kwnames[] = {
33212 (char *) "self",(char *) "newParent", NULL
33213 };
33214
33215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33217 if (!SWIG_IsOK(res1)) {
33218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33219 }
33220 arg1 = reinterpret_cast< wxWindow * >(argp1);
33221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33222 if (!SWIG_IsOK(res2)) {
33223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33224 }
33225 arg2 = reinterpret_cast< wxWindow * >(argp2);
33226 {
33227 PyThreadState* __tstate = wxPyBeginAllowThreads();
33228 result = (bool)(arg1)->Reparent(arg2);
33229 wxPyEndAllowThreads(__tstate);
33230 if (PyErr_Occurred()) SWIG_fail;
33231 }
33232 {
33233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33234 }
33235 return resultobj;
33236 fail:
33237 return NULL;
33238 }
33239
33240
33241 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33242 PyObject *resultobj = 0;
33243 wxWindow *arg1 = (wxWindow *) 0 ;
33244 wxWindow *arg2 = (wxWindow *) 0 ;
33245 void *argp1 = 0 ;
33246 int res1 = 0 ;
33247 void *argp2 = 0 ;
33248 int res2 = 0 ;
33249 PyObject * obj0 = 0 ;
33250 PyObject * obj1 = 0 ;
33251 char * kwnames[] = {
33252 (char *) "self",(char *) "child", NULL
33253 };
33254
33255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33257 if (!SWIG_IsOK(res1)) {
33258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33259 }
33260 arg1 = reinterpret_cast< wxWindow * >(argp1);
33261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33262 if (!SWIG_IsOK(res2)) {
33263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33264 }
33265 arg2 = reinterpret_cast< wxWindow * >(argp2);
33266 {
33267 PyThreadState* __tstate = wxPyBeginAllowThreads();
33268 (arg1)->AddChild(arg2);
33269 wxPyEndAllowThreads(__tstate);
33270 if (PyErr_Occurred()) SWIG_fail;
33271 }
33272 resultobj = SWIG_Py_Void();
33273 return resultobj;
33274 fail:
33275 return NULL;
33276 }
33277
33278
33279 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33280 PyObject *resultobj = 0;
33281 wxWindow *arg1 = (wxWindow *) 0 ;
33282 wxWindow *arg2 = (wxWindow *) 0 ;
33283 void *argp1 = 0 ;
33284 int res1 = 0 ;
33285 void *argp2 = 0 ;
33286 int res2 = 0 ;
33287 PyObject * obj0 = 0 ;
33288 PyObject * obj1 = 0 ;
33289 char * kwnames[] = {
33290 (char *) "self",(char *) "child", NULL
33291 };
33292
33293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33295 if (!SWIG_IsOK(res1)) {
33296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33297 }
33298 arg1 = reinterpret_cast< wxWindow * >(argp1);
33299 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33300 if (!SWIG_IsOK(res2)) {
33301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33302 }
33303 arg2 = reinterpret_cast< wxWindow * >(argp2);
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 (arg1)->RemoveChild(arg2);
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 resultobj = SWIG_Py_Void();
33311 return resultobj;
33312 fail:
33313 return NULL;
33314 }
33315
33316
33317 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33318 PyObject *resultobj = 0;
33319 wxWindow *arg1 = (wxWindow *) 0 ;
33320 bool arg2 ;
33321 void *argp1 = 0 ;
33322 int res1 = 0 ;
33323 bool val2 ;
33324 int ecode2 = 0 ;
33325 PyObject * obj0 = 0 ;
33326 PyObject * obj1 = 0 ;
33327 char * kwnames[] = {
33328 (char *) "self",(char *) "on", NULL
33329 };
33330
33331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33333 if (!SWIG_IsOK(res1)) {
33334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33335 }
33336 arg1 = reinterpret_cast< wxWindow * >(argp1);
33337 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33338 if (!SWIG_IsOK(ecode2)) {
33339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33340 }
33341 arg2 = static_cast< bool >(val2);
33342 {
33343 PyThreadState* __tstate = wxPyBeginAllowThreads();
33344 wxWindow_SetDoubleBuffered(arg1,arg2);
33345 wxPyEndAllowThreads(__tstate);
33346 if (PyErr_Occurred()) SWIG_fail;
33347 }
33348 resultobj = SWIG_Py_Void();
33349 return resultobj;
33350 fail:
33351 return NULL;
33352 }
33353
33354
33355 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33356 PyObject *resultobj = 0;
33357 wxWindow *arg1 = (wxWindow *) 0 ;
33358 long arg2 ;
33359 wxWindow *result = 0 ;
33360 void *argp1 = 0 ;
33361 int res1 = 0 ;
33362 long val2 ;
33363 int ecode2 = 0 ;
33364 PyObject * obj0 = 0 ;
33365 PyObject * obj1 = 0 ;
33366 char * kwnames[] = {
33367 (char *) "self",(char *) "winid", NULL
33368 };
33369
33370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33372 if (!SWIG_IsOK(res1)) {
33373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33374 }
33375 arg1 = reinterpret_cast< wxWindow * >(argp1);
33376 ecode2 = SWIG_AsVal_long(obj1, &val2);
33377 if (!SWIG_IsOK(ecode2)) {
33378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33379 }
33380 arg2 = static_cast< long >(val2);
33381 {
33382 PyThreadState* __tstate = wxPyBeginAllowThreads();
33383 result = (wxWindow *)(arg1)->FindWindow(arg2);
33384 wxPyEndAllowThreads(__tstate);
33385 if (PyErr_Occurred()) SWIG_fail;
33386 }
33387 {
33388 resultobj = wxPyMake_wxObject(result, 0);
33389 }
33390 return resultobj;
33391 fail:
33392 return NULL;
33393 }
33394
33395
33396 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33397 PyObject *resultobj = 0;
33398 wxWindow *arg1 = (wxWindow *) 0 ;
33399 wxString *arg2 = 0 ;
33400 wxWindow *result = 0 ;
33401 void *argp1 = 0 ;
33402 int res1 = 0 ;
33403 bool temp2 = false ;
33404 PyObject * obj0 = 0 ;
33405 PyObject * obj1 = 0 ;
33406 char * kwnames[] = {
33407 (char *) "self",(char *) "name", NULL
33408 };
33409
33410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33412 if (!SWIG_IsOK(res1)) {
33413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33414 }
33415 arg1 = reinterpret_cast< wxWindow * >(argp1);
33416 {
33417 arg2 = wxString_in_helper(obj1);
33418 if (arg2 == NULL) SWIG_fail;
33419 temp2 = true;
33420 }
33421 {
33422 PyThreadState* __tstate = wxPyBeginAllowThreads();
33423 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33424 wxPyEndAllowThreads(__tstate);
33425 if (PyErr_Occurred()) SWIG_fail;
33426 }
33427 {
33428 resultobj = wxPyMake_wxObject(result, 0);
33429 }
33430 {
33431 if (temp2)
33432 delete arg2;
33433 }
33434 return resultobj;
33435 fail:
33436 {
33437 if (temp2)
33438 delete arg2;
33439 }
33440 return NULL;
33441 }
33442
33443
33444 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33445 PyObject *resultobj = 0;
33446 wxWindow *arg1 = (wxWindow *) 0 ;
33447 wxEvtHandler *result = 0 ;
33448 void *argp1 = 0 ;
33449 int res1 = 0 ;
33450 PyObject *swig_obj[1] ;
33451
33452 if (!args) SWIG_fail;
33453 swig_obj[0] = args;
33454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33455 if (!SWIG_IsOK(res1)) {
33456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33457 }
33458 arg1 = reinterpret_cast< wxWindow * >(argp1);
33459 {
33460 PyThreadState* __tstate = wxPyBeginAllowThreads();
33461 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33462 wxPyEndAllowThreads(__tstate);
33463 if (PyErr_Occurred()) SWIG_fail;
33464 }
33465 {
33466 resultobj = wxPyMake_wxObject(result, 0);
33467 }
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33475 PyObject *resultobj = 0;
33476 wxWindow *arg1 = (wxWindow *) 0 ;
33477 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33478 void *argp1 = 0 ;
33479 int res1 = 0 ;
33480 void *argp2 = 0 ;
33481 int res2 = 0 ;
33482 PyObject * obj0 = 0 ;
33483 PyObject * obj1 = 0 ;
33484 char * kwnames[] = {
33485 (char *) "self",(char *) "handler", NULL
33486 };
33487
33488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33490 if (!SWIG_IsOK(res1)) {
33491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33492 }
33493 arg1 = reinterpret_cast< wxWindow * >(argp1);
33494 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33495 if (!SWIG_IsOK(res2)) {
33496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33497 }
33498 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33499 {
33500 PyThreadState* __tstate = wxPyBeginAllowThreads();
33501 (arg1)->SetEventHandler(arg2);
33502 wxPyEndAllowThreads(__tstate);
33503 if (PyErr_Occurred()) SWIG_fail;
33504 }
33505 resultobj = SWIG_Py_Void();
33506 return resultobj;
33507 fail:
33508 return NULL;
33509 }
33510
33511
33512 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33513 PyObject *resultobj = 0;
33514 wxWindow *arg1 = (wxWindow *) 0 ;
33515 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33516 void *argp1 = 0 ;
33517 int res1 = 0 ;
33518 void *argp2 = 0 ;
33519 int res2 = 0 ;
33520 PyObject * obj0 = 0 ;
33521 PyObject * obj1 = 0 ;
33522 char * kwnames[] = {
33523 (char *) "self",(char *) "handler", NULL
33524 };
33525
33526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33528 if (!SWIG_IsOK(res1)) {
33529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33530 }
33531 arg1 = reinterpret_cast< wxWindow * >(argp1);
33532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33533 if (!SWIG_IsOK(res2)) {
33534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33535 }
33536 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33537 {
33538 PyThreadState* __tstate = wxPyBeginAllowThreads();
33539 (arg1)->PushEventHandler(arg2);
33540 wxPyEndAllowThreads(__tstate);
33541 if (PyErr_Occurred()) SWIG_fail;
33542 }
33543 resultobj = SWIG_Py_Void();
33544 return resultobj;
33545 fail:
33546 return NULL;
33547 }
33548
33549
33550 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33551 PyObject *resultobj = 0;
33552 wxWindow *arg1 = (wxWindow *) 0 ;
33553 bool arg2 = (bool) false ;
33554 wxEvtHandler *result = 0 ;
33555 void *argp1 = 0 ;
33556 int res1 = 0 ;
33557 bool val2 ;
33558 int ecode2 = 0 ;
33559 PyObject * obj0 = 0 ;
33560 PyObject * obj1 = 0 ;
33561 char * kwnames[] = {
33562 (char *) "self",(char *) "deleteHandler", NULL
33563 };
33564
33565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33567 if (!SWIG_IsOK(res1)) {
33568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33569 }
33570 arg1 = reinterpret_cast< wxWindow * >(argp1);
33571 if (obj1) {
33572 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33573 if (!SWIG_IsOK(ecode2)) {
33574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33575 }
33576 arg2 = static_cast< bool >(val2);
33577 }
33578 {
33579 PyThreadState* __tstate = wxPyBeginAllowThreads();
33580 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33581 wxPyEndAllowThreads(__tstate);
33582 if (PyErr_Occurred()) SWIG_fail;
33583 }
33584 {
33585 resultobj = wxPyMake_wxObject(result, 0);
33586 }
33587 return resultobj;
33588 fail:
33589 return NULL;
33590 }
33591
33592
33593 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33594 PyObject *resultobj = 0;
33595 wxWindow *arg1 = (wxWindow *) 0 ;
33596 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33597 bool result;
33598 void *argp1 = 0 ;
33599 int res1 = 0 ;
33600 void *argp2 = 0 ;
33601 int res2 = 0 ;
33602 PyObject * obj0 = 0 ;
33603 PyObject * obj1 = 0 ;
33604 char * kwnames[] = {
33605 (char *) "self",(char *) "handler", NULL
33606 };
33607
33608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33610 if (!SWIG_IsOK(res1)) {
33611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33612 }
33613 arg1 = reinterpret_cast< wxWindow * >(argp1);
33614 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33615 if (!SWIG_IsOK(res2)) {
33616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33617 }
33618 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33619 {
33620 PyThreadState* __tstate = wxPyBeginAllowThreads();
33621 result = (bool)(arg1)->RemoveEventHandler(arg2);
33622 wxPyEndAllowThreads(__tstate);
33623 if (PyErr_Occurred()) SWIG_fail;
33624 }
33625 {
33626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33627 }
33628 return resultobj;
33629 fail:
33630 return NULL;
33631 }
33632
33633
33634 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33635 PyObject *resultobj = 0;
33636 wxWindow *arg1 = (wxWindow *) 0 ;
33637 wxValidator *arg2 = 0 ;
33638 void *argp1 = 0 ;
33639 int res1 = 0 ;
33640 void *argp2 = 0 ;
33641 int res2 = 0 ;
33642 PyObject * obj0 = 0 ;
33643 PyObject * obj1 = 0 ;
33644 char * kwnames[] = {
33645 (char *) "self",(char *) "validator", NULL
33646 };
33647
33648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33650 if (!SWIG_IsOK(res1)) {
33651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33652 }
33653 arg1 = reinterpret_cast< wxWindow * >(argp1);
33654 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33655 if (!SWIG_IsOK(res2)) {
33656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33657 }
33658 if (!argp2) {
33659 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33660 }
33661 arg2 = reinterpret_cast< wxValidator * >(argp2);
33662 {
33663 PyThreadState* __tstate = wxPyBeginAllowThreads();
33664 (arg1)->SetValidator((wxValidator const &)*arg2);
33665 wxPyEndAllowThreads(__tstate);
33666 if (PyErr_Occurred()) SWIG_fail;
33667 }
33668 resultobj = SWIG_Py_Void();
33669 return resultobj;
33670 fail:
33671 return NULL;
33672 }
33673
33674
33675 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33676 PyObject *resultobj = 0;
33677 wxWindow *arg1 = (wxWindow *) 0 ;
33678 wxValidator *result = 0 ;
33679 void *argp1 = 0 ;
33680 int res1 = 0 ;
33681 PyObject *swig_obj[1] ;
33682
33683 if (!args) SWIG_fail;
33684 swig_obj[0] = args;
33685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33686 if (!SWIG_IsOK(res1)) {
33687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33688 }
33689 arg1 = reinterpret_cast< wxWindow * >(argp1);
33690 {
33691 PyThreadState* __tstate = wxPyBeginAllowThreads();
33692 result = (wxValidator *)(arg1)->GetValidator();
33693 wxPyEndAllowThreads(__tstate);
33694 if (PyErr_Occurred()) SWIG_fail;
33695 }
33696 {
33697 resultobj = wxPyMake_wxObject(result, (bool)0);
33698 }
33699 return resultobj;
33700 fail:
33701 return NULL;
33702 }
33703
33704
33705 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33706 PyObject *resultobj = 0;
33707 wxWindow *arg1 = (wxWindow *) 0 ;
33708 bool result;
33709 void *argp1 = 0 ;
33710 int res1 = 0 ;
33711 PyObject *swig_obj[1] ;
33712
33713 if (!args) SWIG_fail;
33714 swig_obj[0] = args;
33715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33716 if (!SWIG_IsOK(res1)) {
33717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33718 }
33719 arg1 = reinterpret_cast< wxWindow * >(argp1);
33720 {
33721 PyThreadState* __tstate = wxPyBeginAllowThreads();
33722 result = (bool)(arg1)->Validate();
33723 wxPyEndAllowThreads(__tstate);
33724 if (PyErr_Occurred()) SWIG_fail;
33725 }
33726 {
33727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33728 }
33729 return resultobj;
33730 fail:
33731 return NULL;
33732 }
33733
33734
33735 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33736 PyObject *resultobj = 0;
33737 wxWindow *arg1 = (wxWindow *) 0 ;
33738 bool result;
33739 void *argp1 = 0 ;
33740 int res1 = 0 ;
33741 PyObject *swig_obj[1] ;
33742
33743 if (!args) SWIG_fail;
33744 swig_obj[0] = args;
33745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33746 if (!SWIG_IsOK(res1)) {
33747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33748 }
33749 arg1 = reinterpret_cast< wxWindow * >(argp1);
33750 {
33751 PyThreadState* __tstate = wxPyBeginAllowThreads();
33752 result = (bool)(arg1)->TransferDataToWindow();
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 {
33757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33758 }
33759 return resultobj;
33760 fail:
33761 return NULL;
33762 }
33763
33764
33765 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33766 PyObject *resultobj = 0;
33767 wxWindow *arg1 = (wxWindow *) 0 ;
33768 bool result;
33769 void *argp1 = 0 ;
33770 int res1 = 0 ;
33771 PyObject *swig_obj[1] ;
33772
33773 if (!args) SWIG_fail;
33774 swig_obj[0] = args;
33775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33776 if (!SWIG_IsOK(res1)) {
33777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33778 }
33779 arg1 = reinterpret_cast< wxWindow * >(argp1);
33780 {
33781 PyThreadState* __tstate = wxPyBeginAllowThreads();
33782 result = (bool)(arg1)->TransferDataFromWindow();
33783 wxPyEndAllowThreads(__tstate);
33784 if (PyErr_Occurred()) SWIG_fail;
33785 }
33786 {
33787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33788 }
33789 return resultobj;
33790 fail:
33791 return NULL;
33792 }
33793
33794
33795 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33796 PyObject *resultobj = 0;
33797 wxWindow *arg1 = (wxWindow *) 0 ;
33798 void *argp1 = 0 ;
33799 int res1 = 0 ;
33800 PyObject *swig_obj[1] ;
33801
33802 if (!args) SWIG_fail;
33803 swig_obj[0] = args;
33804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33805 if (!SWIG_IsOK(res1)) {
33806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33807 }
33808 arg1 = reinterpret_cast< wxWindow * >(argp1);
33809 {
33810 PyThreadState* __tstate = wxPyBeginAllowThreads();
33811 (arg1)->InitDialog();
33812 wxPyEndAllowThreads(__tstate);
33813 if (PyErr_Occurred()) SWIG_fail;
33814 }
33815 resultobj = SWIG_Py_Void();
33816 return resultobj;
33817 fail:
33818 return NULL;
33819 }
33820
33821
33822 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33823 PyObject *resultobj = 0;
33824 wxWindow *arg1 = (wxWindow *) 0 ;
33825 wxAcceleratorTable *arg2 = 0 ;
33826 void *argp1 = 0 ;
33827 int res1 = 0 ;
33828 void *argp2 = 0 ;
33829 int res2 = 0 ;
33830 PyObject * obj0 = 0 ;
33831 PyObject * obj1 = 0 ;
33832 char * kwnames[] = {
33833 (char *) "self",(char *) "accel", NULL
33834 };
33835
33836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33838 if (!SWIG_IsOK(res1)) {
33839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33840 }
33841 arg1 = reinterpret_cast< wxWindow * >(argp1);
33842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33843 if (!SWIG_IsOK(res2)) {
33844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33845 }
33846 if (!argp2) {
33847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33848 }
33849 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33850 {
33851 PyThreadState* __tstate = wxPyBeginAllowThreads();
33852 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33853 wxPyEndAllowThreads(__tstate);
33854 if (PyErr_Occurred()) SWIG_fail;
33855 }
33856 resultobj = SWIG_Py_Void();
33857 return resultobj;
33858 fail:
33859 return NULL;
33860 }
33861
33862
33863 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33864 PyObject *resultobj = 0;
33865 wxWindow *arg1 = (wxWindow *) 0 ;
33866 wxAcceleratorTable *result = 0 ;
33867 void *argp1 = 0 ;
33868 int res1 = 0 ;
33869 PyObject *swig_obj[1] ;
33870
33871 if (!args) SWIG_fail;
33872 swig_obj[0] = args;
33873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33874 if (!SWIG_IsOK(res1)) {
33875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33876 }
33877 arg1 = reinterpret_cast< wxWindow * >(argp1);
33878 {
33879 PyThreadState* __tstate = wxPyBeginAllowThreads();
33880 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33881 wxPyEndAllowThreads(__tstate);
33882 if (PyErr_Occurred()) SWIG_fail;
33883 }
33884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33885 return resultobj;
33886 fail:
33887 return NULL;
33888 }
33889
33890
33891 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33892 PyObject *resultobj = 0;
33893 wxWindow *arg1 = (wxWindow *) 0 ;
33894 int arg2 ;
33895 int arg3 ;
33896 int arg4 ;
33897 bool result;
33898 void *argp1 = 0 ;
33899 int res1 = 0 ;
33900 int val2 ;
33901 int ecode2 = 0 ;
33902 int val3 ;
33903 int ecode3 = 0 ;
33904 int val4 ;
33905 int ecode4 = 0 ;
33906 PyObject * obj0 = 0 ;
33907 PyObject * obj1 = 0 ;
33908 PyObject * obj2 = 0 ;
33909 PyObject * obj3 = 0 ;
33910 char * kwnames[] = {
33911 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33912 };
33913
33914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33916 if (!SWIG_IsOK(res1)) {
33917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33918 }
33919 arg1 = reinterpret_cast< wxWindow * >(argp1);
33920 ecode2 = SWIG_AsVal_int(obj1, &val2);
33921 if (!SWIG_IsOK(ecode2)) {
33922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33923 }
33924 arg2 = static_cast< int >(val2);
33925 ecode3 = SWIG_AsVal_int(obj2, &val3);
33926 if (!SWIG_IsOK(ecode3)) {
33927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33928 }
33929 arg3 = static_cast< int >(val3);
33930 ecode4 = SWIG_AsVal_int(obj3, &val4);
33931 if (!SWIG_IsOK(ecode4)) {
33932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33933 }
33934 arg4 = static_cast< int >(val4);
33935 {
33936 PyThreadState* __tstate = wxPyBeginAllowThreads();
33937 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33938 wxPyEndAllowThreads(__tstate);
33939 if (PyErr_Occurred()) SWIG_fail;
33940 }
33941 {
33942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33943 }
33944 return resultobj;
33945 fail:
33946 return NULL;
33947 }
33948
33949
33950 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33951 PyObject *resultobj = 0;
33952 wxWindow *arg1 = (wxWindow *) 0 ;
33953 int arg2 ;
33954 bool result;
33955 void *argp1 = 0 ;
33956 int res1 = 0 ;
33957 int val2 ;
33958 int ecode2 = 0 ;
33959 PyObject * obj0 = 0 ;
33960 PyObject * obj1 = 0 ;
33961 char * kwnames[] = {
33962 (char *) "self",(char *) "hotkeyId", NULL
33963 };
33964
33965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33967 if (!SWIG_IsOK(res1)) {
33968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33969 }
33970 arg1 = reinterpret_cast< wxWindow * >(argp1);
33971 ecode2 = SWIG_AsVal_int(obj1, &val2);
33972 if (!SWIG_IsOK(ecode2)) {
33973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33974 }
33975 arg2 = static_cast< int >(val2);
33976 {
33977 PyThreadState* __tstate = wxPyBeginAllowThreads();
33978 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33979 wxPyEndAllowThreads(__tstate);
33980 if (PyErr_Occurred()) SWIG_fail;
33981 }
33982 {
33983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33984 }
33985 return resultobj;
33986 fail:
33987 return NULL;
33988 }
33989
33990
33991 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33992 PyObject *resultobj = 0;
33993 wxWindow *arg1 = (wxWindow *) 0 ;
33994 wxPoint *arg2 = 0 ;
33995 wxPoint result;
33996 void *argp1 = 0 ;
33997 int res1 = 0 ;
33998 wxPoint temp2 ;
33999 PyObject * obj0 = 0 ;
34000 PyObject * obj1 = 0 ;
34001 char * kwnames[] = {
34002 (char *) "self",(char *) "pt", NULL
34003 };
34004
34005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34007 if (!SWIG_IsOK(res1)) {
34008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34009 }
34010 arg1 = reinterpret_cast< wxWindow * >(argp1);
34011 {
34012 arg2 = &temp2;
34013 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34014 }
34015 {
34016 PyThreadState* __tstate = wxPyBeginAllowThreads();
34017 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34018 wxPyEndAllowThreads(__tstate);
34019 if (PyErr_Occurred()) SWIG_fail;
34020 }
34021 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34022 return resultobj;
34023 fail:
34024 return NULL;
34025 }
34026
34027
34028 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34029 PyObject *resultobj = 0;
34030 wxWindow *arg1 = (wxWindow *) 0 ;
34031 wxSize *arg2 = 0 ;
34032 wxSize result;
34033 void *argp1 = 0 ;
34034 int res1 = 0 ;
34035 wxSize temp2 ;
34036 PyObject * obj0 = 0 ;
34037 PyObject * obj1 = 0 ;
34038 char * kwnames[] = {
34039 (char *) "self",(char *) "sz", NULL
34040 };
34041
34042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34044 if (!SWIG_IsOK(res1)) {
34045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34046 }
34047 arg1 = reinterpret_cast< wxWindow * >(argp1);
34048 {
34049 arg2 = &temp2;
34050 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34051 }
34052 {
34053 PyThreadState* __tstate = wxPyBeginAllowThreads();
34054 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34055 wxPyEndAllowThreads(__tstate);
34056 if (PyErr_Occurred()) SWIG_fail;
34057 }
34058 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34059 return resultobj;
34060 fail:
34061 return NULL;
34062 }
34063
34064
34065 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34066 PyObject *resultobj = 0;
34067 wxWindow *arg1 = (wxWindow *) 0 ;
34068 wxPoint *arg2 = 0 ;
34069 wxPoint result;
34070 void *argp1 = 0 ;
34071 int res1 = 0 ;
34072 wxPoint temp2 ;
34073 PyObject * obj0 = 0 ;
34074 PyObject * obj1 = 0 ;
34075 char * kwnames[] = {
34076 (char *) "self",(char *) "pt", NULL
34077 };
34078
34079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34083 }
34084 arg1 = reinterpret_cast< wxWindow * >(argp1);
34085 {
34086 arg2 = &temp2;
34087 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34088 }
34089 {
34090 PyThreadState* __tstate = wxPyBeginAllowThreads();
34091 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34092 wxPyEndAllowThreads(__tstate);
34093 if (PyErr_Occurred()) SWIG_fail;
34094 }
34095 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34096 return resultobj;
34097 fail:
34098 return NULL;
34099 }
34100
34101
34102 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34103 PyObject *resultobj = 0;
34104 wxWindow *arg1 = (wxWindow *) 0 ;
34105 wxSize *arg2 = 0 ;
34106 wxSize result;
34107 void *argp1 = 0 ;
34108 int res1 = 0 ;
34109 wxSize temp2 ;
34110 PyObject * obj0 = 0 ;
34111 PyObject * obj1 = 0 ;
34112 char * kwnames[] = {
34113 (char *) "self",(char *) "sz", NULL
34114 };
34115
34116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34118 if (!SWIG_IsOK(res1)) {
34119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34120 }
34121 arg1 = reinterpret_cast< wxWindow * >(argp1);
34122 {
34123 arg2 = &temp2;
34124 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34125 }
34126 {
34127 PyThreadState* __tstate = wxPyBeginAllowThreads();
34128 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34129 wxPyEndAllowThreads(__tstate);
34130 if (PyErr_Occurred()) SWIG_fail;
34131 }
34132 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34133 return resultobj;
34134 fail:
34135 return NULL;
34136 }
34137
34138
34139 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34140 PyObject *resultobj = 0;
34141 wxWindow *arg1 = (wxWindow *) 0 ;
34142 wxPoint *arg2 = 0 ;
34143 wxPoint result;
34144 void *argp1 = 0 ;
34145 int res1 = 0 ;
34146 wxPoint temp2 ;
34147 PyObject * obj0 = 0 ;
34148 PyObject * obj1 = 0 ;
34149 char * kwnames[] = {
34150 (char *) "self",(char *) "pt", NULL
34151 };
34152
34153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34155 if (!SWIG_IsOK(res1)) {
34156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34157 }
34158 arg1 = reinterpret_cast< wxWindow * >(argp1);
34159 {
34160 arg2 = &temp2;
34161 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34162 }
34163 {
34164 PyThreadState* __tstate = wxPyBeginAllowThreads();
34165 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34166 wxPyEndAllowThreads(__tstate);
34167 if (PyErr_Occurred()) SWIG_fail;
34168 }
34169 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34170 return resultobj;
34171 fail:
34172 return NULL;
34173 }
34174
34175
34176 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34177 PyObject *resultobj = 0;
34178 wxWindow *arg1 = (wxWindow *) 0 ;
34179 wxSize *arg2 = 0 ;
34180 wxSize result;
34181 void *argp1 = 0 ;
34182 int res1 = 0 ;
34183 wxSize temp2 ;
34184 PyObject * obj0 = 0 ;
34185 PyObject * obj1 = 0 ;
34186 char * kwnames[] = {
34187 (char *) "self",(char *) "sz", NULL
34188 };
34189
34190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34192 if (!SWIG_IsOK(res1)) {
34193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34194 }
34195 arg1 = reinterpret_cast< wxWindow * >(argp1);
34196 {
34197 arg2 = &temp2;
34198 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34199 }
34200 {
34201 PyThreadState* __tstate = wxPyBeginAllowThreads();
34202 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34203 wxPyEndAllowThreads(__tstate);
34204 if (PyErr_Occurred()) SWIG_fail;
34205 }
34206 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34207 return resultobj;
34208 fail:
34209 return NULL;
34210 }
34211
34212
34213 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34214 PyObject *resultobj = 0;
34215 wxWindow *arg1 = (wxWindow *) 0 ;
34216 int arg2 ;
34217 int arg3 ;
34218 void *argp1 = 0 ;
34219 int res1 = 0 ;
34220 int val2 ;
34221 int ecode2 = 0 ;
34222 int val3 ;
34223 int ecode3 = 0 ;
34224 PyObject * obj0 = 0 ;
34225 PyObject * obj1 = 0 ;
34226 PyObject * obj2 = 0 ;
34227 char * kwnames[] = {
34228 (char *) "self",(char *) "x",(char *) "y", NULL
34229 };
34230
34231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34233 if (!SWIG_IsOK(res1)) {
34234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34235 }
34236 arg1 = reinterpret_cast< wxWindow * >(argp1);
34237 ecode2 = SWIG_AsVal_int(obj1, &val2);
34238 if (!SWIG_IsOK(ecode2)) {
34239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34240 }
34241 arg2 = static_cast< int >(val2);
34242 ecode3 = SWIG_AsVal_int(obj2, &val3);
34243 if (!SWIG_IsOK(ecode3)) {
34244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34245 }
34246 arg3 = static_cast< int >(val3);
34247 {
34248 PyThreadState* __tstate = wxPyBeginAllowThreads();
34249 (arg1)->WarpPointer(arg2,arg3);
34250 wxPyEndAllowThreads(__tstate);
34251 if (PyErr_Occurred()) SWIG_fail;
34252 }
34253 resultobj = SWIG_Py_Void();
34254 return resultobj;
34255 fail:
34256 return NULL;
34257 }
34258
34259
34260 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34261 PyObject *resultobj = 0;
34262 wxWindow *arg1 = (wxWindow *) 0 ;
34263 void *argp1 = 0 ;
34264 int res1 = 0 ;
34265 PyObject *swig_obj[1] ;
34266
34267 if (!args) SWIG_fail;
34268 swig_obj[0] = args;
34269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34270 if (!SWIG_IsOK(res1)) {
34271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34272 }
34273 arg1 = reinterpret_cast< wxWindow * >(argp1);
34274 {
34275 PyThreadState* __tstate = wxPyBeginAllowThreads();
34276 (arg1)->CaptureMouse();
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 resultobj = SWIG_Py_Void();
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34288 PyObject *resultobj = 0;
34289 wxWindow *arg1 = (wxWindow *) 0 ;
34290 void *argp1 = 0 ;
34291 int res1 = 0 ;
34292 PyObject *swig_obj[1] ;
34293
34294 if (!args) SWIG_fail;
34295 swig_obj[0] = args;
34296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34297 if (!SWIG_IsOK(res1)) {
34298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34299 }
34300 arg1 = reinterpret_cast< wxWindow * >(argp1);
34301 {
34302 PyThreadState* __tstate = wxPyBeginAllowThreads();
34303 (arg1)->ReleaseMouse();
34304 wxPyEndAllowThreads(__tstate);
34305 if (PyErr_Occurred()) SWIG_fail;
34306 }
34307 resultobj = SWIG_Py_Void();
34308 return resultobj;
34309 fail:
34310 return NULL;
34311 }
34312
34313
34314 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34315 PyObject *resultobj = 0;
34316 wxWindow *result = 0 ;
34317
34318 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34319 {
34320 if (!wxPyCheckForApp()) SWIG_fail;
34321 PyThreadState* __tstate = wxPyBeginAllowThreads();
34322 result = (wxWindow *)wxWindow::GetCapture();
34323 wxPyEndAllowThreads(__tstate);
34324 if (PyErr_Occurred()) SWIG_fail;
34325 }
34326 {
34327 resultobj = wxPyMake_wxObject(result, 0);
34328 }
34329 return resultobj;
34330 fail:
34331 return NULL;
34332 }
34333
34334
34335 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34336 PyObject *resultobj = 0;
34337 wxWindow *arg1 = (wxWindow *) 0 ;
34338 bool result;
34339 void *argp1 = 0 ;
34340 int res1 = 0 ;
34341 PyObject *swig_obj[1] ;
34342
34343 if (!args) SWIG_fail;
34344 swig_obj[0] = args;
34345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34346 if (!SWIG_IsOK(res1)) {
34347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34348 }
34349 arg1 = reinterpret_cast< wxWindow * >(argp1);
34350 {
34351 PyThreadState* __tstate = wxPyBeginAllowThreads();
34352 result = (bool)((wxWindow const *)arg1)->HasCapture();
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 {
34357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34358 }
34359 return resultobj;
34360 fail:
34361 return NULL;
34362 }
34363
34364
34365 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34366 PyObject *resultobj = 0;
34367 wxWindow *arg1 = (wxWindow *) 0 ;
34368 bool arg2 = (bool) true ;
34369 wxRect *arg3 = (wxRect *) NULL ;
34370 void *argp1 = 0 ;
34371 int res1 = 0 ;
34372 bool val2 ;
34373 int ecode2 = 0 ;
34374 void *argp3 = 0 ;
34375 int res3 = 0 ;
34376 PyObject * obj0 = 0 ;
34377 PyObject * obj1 = 0 ;
34378 PyObject * obj2 = 0 ;
34379 char * kwnames[] = {
34380 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34381 };
34382
34383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34385 if (!SWIG_IsOK(res1)) {
34386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34387 }
34388 arg1 = reinterpret_cast< wxWindow * >(argp1);
34389 if (obj1) {
34390 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34391 if (!SWIG_IsOK(ecode2)) {
34392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34393 }
34394 arg2 = static_cast< bool >(val2);
34395 }
34396 if (obj2) {
34397 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34398 if (!SWIG_IsOK(res3)) {
34399 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34400 }
34401 arg3 = reinterpret_cast< wxRect * >(argp3);
34402 }
34403 {
34404 PyThreadState* __tstate = wxPyBeginAllowThreads();
34405 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34406 wxPyEndAllowThreads(__tstate);
34407 if (PyErr_Occurred()) SWIG_fail;
34408 }
34409 resultobj = SWIG_Py_Void();
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34417 PyObject *resultobj = 0;
34418 wxWindow *arg1 = (wxWindow *) 0 ;
34419 wxRect *arg2 = 0 ;
34420 bool arg3 = (bool) true ;
34421 void *argp1 = 0 ;
34422 int res1 = 0 ;
34423 wxRect temp2 ;
34424 bool val3 ;
34425 int ecode3 = 0 ;
34426 PyObject * obj0 = 0 ;
34427 PyObject * obj1 = 0 ;
34428 PyObject * obj2 = 0 ;
34429 char * kwnames[] = {
34430 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34431 };
34432
34433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34435 if (!SWIG_IsOK(res1)) {
34436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34437 }
34438 arg1 = reinterpret_cast< wxWindow * >(argp1);
34439 {
34440 arg2 = &temp2;
34441 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34442 }
34443 if (obj2) {
34444 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34445 if (!SWIG_IsOK(ecode3)) {
34446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34447 }
34448 arg3 = static_cast< bool >(val3);
34449 }
34450 {
34451 PyThreadState* __tstate = wxPyBeginAllowThreads();
34452 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34453 wxPyEndAllowThreads(__tstate);
34454 if (PyErr_Occurred()) SWIG_fail;
34455 }
34456 resultobj = SWIG_Py_Void();
34457 return resultobj;
34458 fail:
34459 return NULL;
34460 }
34461
34462
34463 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34464 PyObject *resultobj = 0;
34465 wxWindow *arg1 = (wxWindow *) 0 ;
34466 void *argp1 = 0 ;
34467 int res1 = 0 ;
34468 PyObject *swig_obj[1] ;
34469
34470 if (!args) SWIG_fail;
34471 swig_obj[0] = args;
34472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34473 if (!SWIG_IsOK(res1)) {
34474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34475 }
34476 arg1 = reinterpret_cast< wxWindow * >(argp1);
34477 {
34478 PyThreadState* __tstate = wxPyBeginAllowThreads();
34479 (arg1)->Update();
34480 wxPyEndAllowThreads(__tstate);
34481 if (PyErr_Occurred()) SWIG_fail;
34482 }
34483 resultobj = SWIG_Py_Void();
34484 return resultobj;
34485 fail:
34486 return NULL;
34487 }
34488
34489
34490 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34491 PyObject *resultobj = 0;
34492 wxWindow *arg1 = (wxWindow *) 0 ;
34493 void *argp1 = 0 ;
34494 int res1 = 0 ;
34495 PyObject *swig_obj[1] ;
34496
34497 if (!args) SWIG_fail;
34498 swig_obj[0] = args;
34499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34500 if (!SWIG_IsOK(res1)) {
34501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34502 }
34503 arg1 = reinterpret_cast< wxWindow * >(argp1);
34504 {
34505 PyThreadState* __tstate = wxPyBeginAllowThreads();
34506 (arg1)->ClearBackground();
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 resultobj = SWIG_Py_Void();
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34518 PyObject *resultobj = 0;
34519 wxWindow *arg1 = (wxWindow *) 0 ;
34520 void *argp1 = 0 ;
34521 int res1 = 0 ;
34522 PyObject *swig_obj[1] ;
34523
34524 if (!args) SWIG_fail;
34525 swig_obj[0] = args;
34526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34527 if (!SWIG_IsOK(res1)) {
34528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34529 }
34530 arg1 = reinterpret_cast< wxWindow * >(argp1);
34531 {
34532 PyThreadState* __tstate = wxPyBeginAllowThreads();
34533 (arg1)->Freeze();
34534 wxPyEndAllowThreads(__tstate);
34535 if (PyErr_Occurred()) SWIG_fail;
34536 }
34537 resultobj = SWIG_Py_Void();
34538 return resultobj;
34539 fail:
34540 return NULL;
34541 }
34542
34543
34544 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34545 PyObject *resultobj = 0;
34546 wxWindow *arg1 = (wxWindow *) 0 ;
34547 void *argp1 = 0 ;
34548 int res1 = 0 ;
34549 PyObject *swig_obj[1] ;
34550
34551 if (!args) SWIG_fail;
34552 swig_obj[0] = args;
34553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34554 if (!SWIG_IsOK(res1)) {
34555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34556 }
34557 arg1 = reinterpret_cast< wxWindow * >(argp1);
34558 {
34559 PyThreadState* __tstate = wxPyBeginAllowThreads();
34560 (arg1)->Thaw();
34561 wxPyEndAllowThreads(__tstate);
34562 if (PyErr_Occurred()) SWIG_fail;
34563 }
34564 resultobj = SWIG_Py_Void();
34565 return resultobj;
34566 fail:
34567 return NULL;
34568 }
34569
34570
34571 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34572 PyObject *resultobj = 0;
34573 wxWindow *arg1 = (wxWindow *) 0 ;
34574 wxDC *arg2 = 0 ;
34575 void *argp1 = 0 ;
34576 int res1 = 0 ;
34577 void *argp2 = 0 ;
34578 int res2 = 0 ;
34579 PyObject * obj0 = 0 ;
34580 PyObject * obj1 = 0 ;
34581 char * kwnames[] = {
34582 (char *) "self",(char *) "dc", NULL
34583 };
34584
34585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34587 if (!SWIG_IsOK(res1)) {
34588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34589 }
34590 arg1 = reinterpret_cast< wxWindow * >(argp1);
34591 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34592 if (!SWIG_IsOK(res2)) {
34593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34594 }
34595 if (!argp2) {
34596 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34597 }
34598 arg2 = reinterpret_cast< wxDC * >(argp2);
34599 {
34600 PyThreadState* __tstate = wxPyBeginAllowThreads();
34601 (arg1)->PrepareDC(*arg2);
34602 wxPyEndAllowThreads(__tstate);
34603 if (PyErr_Occurred()) SWIG_fail;
34604 }
34605 resultobj = SWIG_Py_Void();
34606 return resultobj;
34607 fail:
34608 return NULL;
34609 }
34610
34611
34612 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34613 PyObject *resultobj = 0;
34614 wxWindow *arg1 = (wxWindow *) 0 ;
34615 wxRegion *result = 0 ;
34616 void *argp1 = 0 ;
34617 int res1 = 0 ;
34618 PyObject *swig_obj[1] ;
34619
34620 if (!args) SWIG_fail;
34621 swig_obj[0] = args;
34622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34623 if (!SWIG_IsOK(res1)) {
34624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34625 }
34626 arg1 = reinterpret_cast< wxWindow * >(argp1);
34627 {
34628 PyThreadState* __tstate = wxPyBeginAllowThreads();
34629 {
34630 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34631 result = (wxRegion *) &_result_ref;
34632 }
34633 wxPyEndAllowThreads(__tstate);
34634 if (PyErr_Occurred()) SWIG_fail;
34635 }
34636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34637 return resultobj;
34638 fail:
34639 return NULL;
34640 }
34641
34642
34643 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34644 PyObject *resultobj = 0;
34645 wxWindow *arg1 = (wxWindow *) 0 ;
34646 wxRect result;
34647 void *argp1 = 0 ;
34648 int res1 = 0 ;
34649 PyObject *swig_obj[1] ;
34650
34651 if (!args) SWIG_fail;
34652 swig_obj[0] = args;
34653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34654 if (!SWIG_IsOK(res1)) {
34655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34656 }
34657 arg1 = reinterpret_cast< wxWindow * >(argp1);
34658 {
34659 PyThreadState* __tstate = wxPyBeginAllowThreads();
34660 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34661 wxPyEndAllowThreads(__tstate);
34662 if (PyErr_Occurred()) SWIG_fail;
34663 }
34664 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34665 return resultobj;
34666 fail:
34667 return NULL;
34668 }
34669
34670
34671 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34672 PyObject *resultobj = 0;
34673 wxWindow *arg1 = (wxWindow *) 0 ;
34674 int arg2 ;
34675 int arg3 ;
34676 int arg4 = (int) 1 ;
34677 int arg5 = (int) 1 ;
34678 bool result;
34679 void *argp1 = 0 ;
34680 int res1 = 0 ;
34681 int val2 ;
34682 int ecode2 = 0 ;
34683 int val3 ;
34684 int ecode3 = 0 ;
34685 int val4 ;
34686 int ecode4 = 0 ;
34687 int val5 ;
34688 int ecode5 = 0 ;
34689 PyObject * obj0 = 0 ;
34690 PyObject * obj1 = 0 ;
34691 PyObject * obj2 = 0 ;
34692 PyObject * obj3 = 0 ;
34693 PyObject * obj4 = 0 ;
34694 char * kwnames[] = {
34695 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34696 };
34697
34698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34700 if (!SWIG_IsOK(res1)) {
34701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34702 }
34703 arg1 = reinterpret_cast< wxWindow * >(argp1);
34704 ecode2 = SWIG_AsVal_int(obj1, &val2);
34705 if (!SWIG_IsOK(ecode2)) {
34706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34707 }
34708 arg2 = static_cast< int >(val2);
34709 ecode3 = SWIG_AsVal_int(obj2, &val3);
34710 if (!SWIG_IsOK(ecode3)) {
34711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34712 }
34713 arg3 = static_cast< int >(val3);
34714 if (obj3) {
34715 ecode4 = SWIG_AsVal_int(obj3, &val4);
34716 if (!SWIG_IsOK(ecode4)) {
34717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34718 }
34719 arg4 = static_cast< int >(val4);
34720 }
34721 if (obj4) {
34722 ecode5 = SWIG_AsVal_int(obj4, &val5);
34723 if (!SWIG_IsOK(ecode5)) {
34724 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34725 }
34726 arg5 = static_cast< int >(val5);
34727 }
34728 {
34729 PyThreadState* __tstate = wxPyBeginAllowThreads();
34730 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34731 wxPyEndAllowThreads(__tstate);
34732 if (PyErr_Occurred()) SWIG_fail;
34733 }
34734 {
34735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34736 }
34737 return resultobj;
34738 fail:
34739 return NULL;
34740 }
34741
34742
34743 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34744 PyObject *resultobj = 0;
34745 wxWindow *arg1 = (wxWindow *) 0 ;
34746 wxPoint *arg2 = 0 ;
34747 bool result;
34748 void *argp1 = 0 ;
34749 int res1 = 0 ;
34750 wxPoint temp2 ;
34751 PyObject * obj0 = 0 ;
34752 PyObject * obj1 = 0 ;
34753 char * kwnames[] = {
34754 (char *) "self",(char *) "pt", NULL
34755 };
34756
34757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34759 if (!SWIG_IsOK(res1)) {
34760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34761 }
34762 arg1 = reinterpret_cast< wxWindow * >(argp1);
34763 {
34764 arg2 = &temp2;
34765 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34766 }
34767 {
34768 PyThreadState* __tstate = wxPyBeginAllowThreads();
34769 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 {
34774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34775 }
34776 return resultobj;
34777 fail:
34778 return NULL;
34779 }
34780
34781
34782 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34783 PyObject *resultobj = 0;
34784 wxWindow *arg1 = (wxWindow *) 0 ;
34785 wxRect *arg2 = 0 ;
34786 bool result;
34787 void *argp1 = 0 ;
34788 int res1 = 0 ;
34789 wxRect temp2 ;
34790 PyObject * obj0 = 0 ;
34791 PyObject * obj1 = 0 ;
34792 char * kwnames[] = {
34793 (char *) "self",(char *) "rect", NULL
34794 };
34795
34796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34798 if (!SWIG_IsOK(res1)) {
34799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34800 }
34801 arg1 = reinterpret_cast< wxWindow * >(argp1);
34802 {
34803 arg2 = &temp2;
34804 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34805 }
34806 {
34807 PyThreadState* __tstate = wxPyBeginAllowThreads();
34808 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34809 wxPyEndAllowThreads(__tstate);
34810 if (PyErr_Occurred()) SWIG_fail;
34811 }
34812 {
34813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34814 }
34815 return resultobj;
34816 fail:
34817 return NULL;
34818 }
34819
34820
34821 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34822 PyObject *resultobj = 0;
34823 wxWindow *arg1 = (wxWindow *) 0 ;
34824 SwigValueWrapper<wxVisualAttributes > result;
34825 void *argp1 = 0 ;
34826 int res1 = 0 ;
34827 PyObject *swig_obj[1] ;
34828
34829 if (!args) SWIG_fail;
34830 swig_obj[0] = args;
34831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34832 if (!SWIG_IsOK(res1)) {
34833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34834 }
34835 arg1 = reinterpret_cast< wxWindow * >(argp1);
34836 {
34837 PyThreadState* __tstate = wxPyBeginAllowThreads();
34838 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34839 wxPyEndAllowThreads(__tstate);
34840 if (PyErr_Occurred()) SWIG_fail;
34841 }
34842 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34843 return resultobj;
34844 fail:
34845 return NULL;
34846 }
34847
34848
34849 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34850 PyObject *resultobj = 0;
34851 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34852 SwigValueWrapper<wxVisualAttributes > result;
34853 int val1 ;
34854 int ecode1 = 0 ;
34855 PyObject * obj0 = 0 ;
34856 char * kwnames[] = {
34857 (char *) "variant", NULL
34858 };
34859
34860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34861 if (obj0) {
34862 ecode1 = SWIG_AsVal_int(obj0, &val1);
34863 if (!SWIG_IsOK(ecode1)) {
34864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34865 }
34866 arg1 = static_cast< wxWindowVariant >(val1);
34867 }
34868 {
34869 if (!wxPyCheckForApp()) SWIG_fail;
34870 PyThreadState* __tstate = wxPyBeginAllowThreads();
34871 result = wxWindow::GetClassDefaultAttributes(arg1);
34872 wxPyEndAllowThreads(__tstate);
34873 if (PyErr_Occurred()) SWIG_fail;
34874 }
34875 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34876 return resultobj;
34877 fail:
34878 return NULL;
34879 }
34880
34881
34882 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34883 PyObject *resultobj = 0;
34884 wxWindow *arg1 = (wxWindow *) 0 ;
34885 wxColour *arg2 = 0 ;
34886 bool result;
34887 void *argp1 = 0 ;
34888 int res1 = 0 ;
34889 wxColour temp2 ;
34890 PyObject * obj0 = 0 ;
34891 PyObject * obj1 = 0 ;
34892 char * kwnames[] = {
34893 (char *) "self",(char *) "colour", NULL
34894 };
34895
34896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34898 if (!SWIG_IsOK(res1)) {
34899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34900 }
34901 arg1 = reinterpret_cast< wxWindow * >(argp1);
34902 {
34903 arg2 = &temp2;
34904 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34905 }
34906 {
34907 PyThreadState* __tstate = wxPyBeginAllowThreads();
34908 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34909 wxPyEndAllowThreads(__tstate);
34910 if (PyErr_Occurred()) SWIG_fail;
34911 }
34912 {
34913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34914 }
34915 return resultobj;
34916 fail:
34917 return NULL;
34918 }
34919
34920
34921 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34922 PyObject *resultobj = 0;
34923 wxWindow *arg1 = (wxWindow *) 0 ;
34924 wxColour *arg2 = 0 ;
34925 void *argp1 = 0 ;
34926 int res1 = 0 ;
34927 wxColour temp2 ;
34928 PyObject * obj0 = 0 ;
34929 PyObject * obj1 = 0 ;
34930 char * kwnames[] = {
34931 (char *) "self",(char *) "colour", NULL
34932 };
34933
34934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34936 if (!SWIG_IsOK(res1)) {
34937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34938 }
34939 arg1 = reinterpret_cast< wxWindow * >(argp1);
34940 {
34941 arg2 = &temp2;
34942 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34943 }
34944 {
34945 PyThreadState* __tstate = wxPyBeginAllowThreads();
34946 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34947 wxPyEndAllowThreads(__tstate);
34948 if (PyErr_Occurred()) SWIG_fail;
34949 }
34950 resultobj = SWIG_Py_Void();
34951 return resultobj;
34952 fail:
34953 return NULL;
34954 }
34955
34956
34957 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34958 PyObject *resultobj = 0;
34959 wxWindow *arg1 = (wxWindow *) 0 ;
34960 wxColour *arg2 = 0 ;
34961 bool result;
34962 void *argp1 = 0 ;
34963 int res1 = 0 ;
34964 wxColour temp2 ;
34965 PyObject * obj0 = 0 ;
34966 PyObject * obj1 = 0 ;
34967 char * kwnames[] = {
34968 (char *) "self",(char *) "colour", NULL
34969 };
34970
34971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34973 if (!SWIG_IsOK(res1)) {
34974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34975 }
34976 arg1 = reinterpret_cast< wxWindow * >(argp1);
34977 {
34978 arg2 = &temp2;
34979 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34980 }
34981 {
34982 PyThreadState* __tstate = wxPyBeginAllowThreads();
34983 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34984 wxPyEndAllowThreads(__tstate);
34985 if (PyErr_Occurred()) SWIG_fail;
34986 }
34987 {
34988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34989 }
34990 return resultobj;
34991 fail:
34992 return NULL;
34993 }
34994
34995
34996 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34997 PyObject *resultobj = 0;
34998 wxWindow *arg1 = (wxWindow *) 0 ;
34999 wxColour *arg2 = 0 ;
35000 void *argp1 = 0 ;
35001 int res1 = 0 ;
35002 wxColour temp2 ;
35003 PyObject * obj0 = 0 ;
35004 PyObject * obj1 = 0 ;
35005 char * kwnames[] = {
35006 (char *) "self",(char *) "colour", NULL
35007 };
35008
35009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35011 if (!SWIG_IsOK(res1)) {
35012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35013 }
35014 arg1 = reinterpret_cast< wxWindow * >(argp1);
35015 {
35016 arg2 = &temp2;
35017 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35018 }
35019 {
35020 PyThreadState* __tstate = wxPyBeginAllowThreads();
35021 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35022 wxPyEndAllowThreads(__tstate);
35023 if (PyErr_Occurred()) SWIG_fail;
35024 }
35025 resultobj = SWIG_Py_Void();
35026 return resultobj;
35027 fail:
35028 return NULL;
35029 }
35030
35031
35032 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35033 PyObject *resultobj = 0;
35034 wxWindow *arg1 = (wxWindow *) 0 ;
35035 wxColour result;
35036 void *argp1 = 0 ;
35037 int res1 = 0 ;
35038 PyObject *swig_obj[1] ;
35039
35040 if (!args) SWIG_fail;
35041 swig_obj[0] = args;
35042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35043 if (!SWIG_IsOK(res1)) {
35044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35045 }
35046 arg1 = reinterpret_cast< wxWindow * >(argp1);
35047 {
35048 PyThreadState* __tstate = wxPyBeginAllowThreads();
35049 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35050 wxPyEndAllowThreads(__tstate);
35051 if (PyErr_Occurred()) SWIG_fail;
35052 }
35053 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35054 return resultobj;
35055 fail:
35056 return NULL;
35057 }
35058
35059
35060 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35061 PyObject *resultobj = 0;
35062 wxWindow *arg1 = (wxWindow *) 0 ;
35063 wxColour result;
35064 void *argp1 = 0 ;
35065 int res1 = 0 ;
35066 PyObject *swig_obj[1] ;
35067
35068 if (!args) SWIG_fail;
35069 swig_obj[0] = args;
35070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35071 if (!SWIG_IsOK(res1)) {
35072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35073 }
35074 arg1 = reinterpret_cast< wxWindow * >(argp1);
35075 {
35076 PyThreadState* __tstate = wxPyBeginAllowThreads();
35077 result = ((wxWindow const *)arg1)->GetForegroundColour();
35078 wxPyEndAllowThreads(__tstate);
35079 if (PyErr_Occurred()) SWIG_fail;
35080 }
35081 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35082 return resultobj;
35083 fail:
35084 return NULL;
35085 }
35086
35087
35088 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35089 PyObject *resultobj = 0;
35090 wxWindow *arg1 = (wxWindow *) 0 ;
35091 bool result;
35092 void *argp1 = 0 ;
35093 int res1 = 0 ;
35094 PyObject *swig_obj[1] ;
35095
35096 if (!args) SWIG_fail;
35097 swig_obj[0] = args;
35098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35099 if (!SWIG_IsOK(res1)) {
35100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35101 }
35102 arg1 = reinterpret_cast< wxWindow * >(argp1);
35103 {
35104 PyThreadState* __tstate = wxPyBeginAllowThreads();
35105 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35106 wxPyEndAllowThreads(__tstate);
35107 if (PyErr_Occurred()) SWIG_fail;
35108 }
35109 {
35110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35111 }
35112 return resultobj;
35113 fail:
35114 return NULL;
35115 }
35116
35117
35118 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35119 PyObject *resultobj = 0;
35120 wxWindow *arg1 = (wxWindow *) 0 ;
35121 bool result;
35122 void *argp1 = 0 ;
35123 int res1 = 0 ;
35124 PyObject *swig_obj[1] ;
35125
35126 if (!args) SWIG_fail;
35127 swig_obj[0] = args;
35128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35129 if (!SWIG_IsOK(res1)) {
35130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35131 }
35132 arg1 = reinterpret_cast< wxWindow * >(argp1);
35133 {
35134 PyThreadState* __tstate = wxPyBeginAllowThreads();
35135 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35136 wxPyEndAllowThreads(__tstate);
35137 if (PyErr_Occurred()) SWIG_fail;
35138 }
35139 {
35140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35141 }
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35149 PyObject *resultobj = 0;
35150 wxWindow *arg1 = (wxWindow *) 0 ;
35151 wxBackgroundStyle arg2 ;
35152 bool result;
35153 void *argp1 = 0 ;
35154 int res1 = 0 ;
35155 int val2 ;
35156 int ecode2 = 0 ;
35157 PyObject * obj0 = 0 ;
35158 PyObject * obj1 = 0 ;
35159 char * kwnames[] = {
35160 (char *) "self",(char *) "style", NULL
35161 };
35162
35163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35165 if (!SWIG_IsOK(res1)) {
35166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35167 }
35168 arg1 = reinterpret_cast< wxWindow * >(argp1);
35169 ecode2 = SWIG_AsVal_int(obj1, &val2);
35170 if (!SWIG_IsOK(ecode2)) {
35171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35172 }
35173 arg2 = static_cast< wxBackgroundStyle >(val2);
35174 {
35175 PyThreadState* __tstate = wxPyBeginAllowThreads();
35176 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 {
35181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35182 }
35183 return resultobj;
35184 fail:
35185 return NULL;
35186 }
35187
35188
35189 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35190 PyObject *resultobj = 0;
35191 wxWindow *arg1 = (wxWindow *) 0 ;
35192 wxBackgroundStyle result;
35193 void *argp1 = 0 ;
35194 int res1 = 0 ;
35195 PyObject *swig_obj[1] ;
35196
35197 if (!args) SWIG_fail;
35198 swig_obj[0] = args;
35199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35200 if (!SWIG_IsOK(res1)) {
35201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35202 }
35203 arg1 = reinterpret_cast< wxWindow * >(argp1);
35204 {
35205 PyThreadState* __tstate = wxPyBeginAllowThreads();
35206 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35207 wxPyEndAllowThreads(__tstate);
35208 if (PyErr_Occurred()) SWIG_fail;
35209 }
35210 resultobj = SWIG_From_int(static_cast< int >(result));
35211 return resultobj;
35212 fail:
35213 return NULL;
35214 }
35215
35216
35217 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35218 PyObject *resultobj = 0;
35219 wxWindow *arg1 = (wxWindow *) 0 ;
35220 bool result;
35221 void *argp1 = 0 ;
35222 int res1 = 0 ;
35223 PyObject *swig_obj[1] ;
35224
35225 if (!args) SWIG_fail;
35226 swig_obj[0] = args;
35227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35228 if (!SWIG_IsOK(res1)) {
35229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35230 }
35231 arg1 = reinterpret_cast< wxWindow * >(argp1);
35232 {
35233 PyThreadState* __tstate = wxPyBeginAllowThreads();
35234 result = (bool)(arg1)->HasTransparentBackground();
35235 wxPyEndAllowThreads(__tstate);
35236 if (PyErr_Occurred()) SWIG_fail;
35237 }
35238 {
35239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35240 }
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35248 PyObject *resultobj = 0;
35249 wxWindow *arg1 = (wxWindow *) 0 ;
35250 wxCursor *arg2 = 0 ;
35251 bool result;
35252 void *argp1 = 0 ;
35253 int res1 = 0 ;
35254 void *argp2 = 0 ;
35255 int res2 = 0 ;
35256 PyObject * obj0 = 0 ;
35257 PyObject * obj1 = 0 ;
35258 char * kwnames[] = {
35259 (char *) "self",(char *) "cursor", NULL
35260 };
35261
35262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35264 if (!SWIG_IsOK(res1)) {
35265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35266 }
35267 arg1 = reinterpret_cast< wxWindow * >(argp1);
35268 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35269 if (!SWIG_IsOK(res2)) {
35270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35271 }
35272 if (!argp2) {
35273 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35274 }
35275 arg2 = reinterpret_cast< wxCursor * >(argp2);
35276 {
35277 PyThreadState* __tstate = wxPyBeginAllowThreads();
35278 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35279 wxPyEndAllowThreads(__tstate);
35280 if (PyErr_Occurred()) SWIG_fail;
35281 }
35282 {
35283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35284 }
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35292 PyObject *resultobj = 0;
35293 wxWindow *arg1 = (wxWindow *) 0 ;
35294 wxCursor result;
35295 void *argp1 = 0 ;
35296 int res1 = 0 ;
35297 PyObject *swig_obj[1] ;
35298
35299 if (!args) SWIG_fail;
35300 swig_obj[0] = args;
35301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35302 if (!SWIG_IsOK(res1)) {
35303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35304 }
35305 arg1 = reinterpret_cast< wxWindow * >(argp1);
35306 {
35307 PyThreadState* __tstate = wxPyBeginAllowThreads();
35308 result = (arg1)->GetCursor();
35309 wxPyEndAllowThreads(__tstate);
35310 if (PyErr_Occurred()) SWIG_fail;
35311 }
35312 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35313 return resultobj;
35314 fail:
35315 return NULL;
35316 }
35317
35318
35319 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35320 PyObject *resultobj = 0;
35321 wxWindow *arg1 = (wxWindow *) 0 ;
35322 wxFont *arg2 = 0 ;
35323 bool result;
35324 void *argp1 = 0 ;
35325 int res1 = 0 ;
35326 void *argp2 = 0 ;
35327 int res2 = 0 ;
35328 PyObject * obj0 = 0 ;
35329 PyObject * obj1 = 0 ;
35330 char * kwnames[] = {
35331 (char *) "self",(char *) "font", NULL
35332 };
35333
35334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35336 if (!SWIG_IsOK(res1)) {
35337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35338 }
35339 arg1 = reinterpret_cast< wxWindow * >(argp1);
35340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35341 if (!SWIG_IsOK(res2)) {
35342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35343 }
35344 if (!argp2) {
35345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35346 }
35347 arg2 = reinterpret_cast< wxFont * >(argp2);
35348 {
35349 PyThreadState* __tstate = wxPyBeginAllowThreads();
35350 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35351 wxPyEndAllowThreads(__tstate);
35352 if (PyErr_Occurred()) SWIG_fail;
35353 }
35354 {
35355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35356 }
35357 return resultobj;
35358 fail:
35359 return NULL;
35360 }
35361
35362
35363 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35364 PyObject *resultobj = 0;
35365 wxWindow *arg1 = (wxWindow *) 0 ;
35366 wxFont *arg2 = 0 ;
35367 void *argp1 = 0 ;
35368 int res1 = 0 ;
35369 void *argp2 = 0 ;
35370 int res2 = 0 ;
35371 PyObject * obj0 = 0 ;
35372 PyObject * obj1 = 0 ;
35373 char * kwnames[] = {
35374 (char *) "self",(char *) "font", NULL
35375 };
35376
35377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35379 if (!SWIG_IsOK(res1)) {
35380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35381 }
35382 arg1 = reinterpret_cast< wxWindow * >(argp1);
35383 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35384 if (!SWIG_IsOK(res2)) {
35385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35386 }
35387 if (!argp2) {
35388 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35389 }
35390 arg2 = reinterpret_cast< wxFont * >(argp2);
35391 {
35392 PyThreadState* __tstate = wxPyBeginAllowThreads();
35393 (arg1)->SetOwnFont((wxFont const &)*arg2);
35394 wxPyEndAllowThreads(__tstate);
35395 if (PyErr_Occurred()) SWIG_fail;
35396 }
35397 resultobj = SWIG_Py_Void();
35398 return resultobj;
35399 fail:
35400 return NULL;
35401 }
35402
35403
35404 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35405 PyObject *resultobj = 0;
35406 wxWindow *arg1 = (wxWindow *) 0 ;
35407 wxFont result;
35408 void *argp1 = 0 ;
35409 int res1 = 0 ;
35410 PyObject *swig_obj[1] ;
35411
35412 if (!args) SWIG_fail;
35413 swig_obj[0] = args;
35414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35415 if (!SWIG_IsOK(res1)) {
35416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35417 }
35418 arg1 = reinterpret_cast< wxWindow * >(argp1);
35419 {
35420 PyThreadState* __tstate = wxPyBeginAllowThreads();
35421 result = (arg1)->GetFont();
35422 wxPyEndAllowThreads(__tstate);
35423 if (PyErr_Occurred()) SWIG_fail;
35424 }
35425 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35426 return resultobj;
35427 fail:
35428 return NULL;
35429 }
35430
35431
35432 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35433 PyObject *resultobj = 0;
35434 wxWindow *arg1 = (wxWindow *) 0 ;
35435 wxCaret *arg2 = (wxCaret *) 0 ;
35436 void *argp1 = 0 ;
35437 int res1 = 0 ;
35438 int res2 = 0 ;
35439 PyObject * obj0 = 0 ;
35440 PyObject * obj1 = 0 ;
35441 char * kwnames[] = {
35442 (char *) "self",(char *) "caret", NULL
35443 };
35444
35445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35449 }
35450 arg1 = reinterpret_cast< wxWindow * >(argp1);
35451 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35452 if (!SWIG_IsOK(res2)) {
35453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35454 }
35455 {
35456 PyThreadState* __tstate = wxPyBeginAllowThreads();
35457 (arg1)->SetCaret(arg2);
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 resultobj = SWIG_Py_Void();
35462 return resultobj;
35463 fail:
35464 return NULL;
35465 }
35466
35467
35468 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35469 PyObject *resultobj = 0;
35470 wxWindow *arg1 = (wxWindow *) 0 ;
35471 wxCaret *result = 0 ;
35472 void *argp1 = 0 ;
35473 int res1 = 0 ;
35474 PyObject *swig_obj[1] ;
35475
35476 if (!args) SWIG_fail;
35477 swig_obj[0] = args;
35478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35479 if (!SWIG_IsOK(res1)) {
35480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35481 }
35482 arg1 = reinterpret_cast< wxWindow * >(argp1);
35483 {
35484 PyThreadState* __tstate = wxPyBeginAllowThreads();
35485 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35486 wxPyEndAllowThreads(__tstate);
35487 if (PyErr_Occurred()) SWIG_fail;
35488 }
35489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35490 return resultobj;
35491 fail:
35492 return NULL;
35493 }
35494
35495
35496 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35497 PyObject *resultobj = 0;
35498 wxWindow *arg1 = (wxWindow *) 0 ;
35499 int result;
35500 void *argp1 = 0 ;
35501 int res1 = 0 ;
35502 PyObject *swig_obj[1] ;
35503
35504 if (!args) SWIG_fail;
35505 swig_obj[0] = args;
35506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35507 if (!SWIG_IsOK(res1)) {
35508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35509 }
35510 arg1 = reinterpret_cast< wxWindow * >(argp1);
35511 {
35512 PyThreadState* __tstate = wxPyBeginAllowThreads();
35513 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35514 wxPyEndAllowThreads(__tstate);
35515 if (PyErr_Occurred()) SWIG_fail;
35516 }
35517 resultobj = SWIG_From_int(static_cast< int >(result));
35518 return resultobj;
35519 fail:
35520 return NULL;
35521 }
35522
35523
35524 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35525 PyObject *resultobj = 0;
35526 wxWindow *arg1 = (wxWindow *) 0 ;
35527 int result;
35528 void *argp1 = 0 ;
35529 int res1 = 0 ;
35530 PyObject *swig_obj[1] ;
35531
35532 if (!args) SWIG_fail;
35533 swig_obj[0] = args;
35534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35535 if (!SWIG_IsOK(res1)) {
35536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35537 }
35538 arg1 = reinterpret_cast< wxWindow * >(argp1);
35539 {
35540 PyThreadState* __tstate = wxPyBeginAllowThreads();
35541 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35542 wxPyEndAllowThreads(__tstate);
35543 if (PyErr_Occurred()) SWIG_fail;
35544 }
35545 resultobj = SWIG_From_int(static_cast< int >(result));
35546 return resultobj;
35547 fail:
35548 return NULL;
35549 }
35550
35551
35552 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35553 PyObject *resultobj = 0;
35554 wxWindow *arg1 = (wxWindow *) 0 ;
35555 wxString *arg2 = 0 ;
35556 int *arg3 = (int *) 0 ;
35557 int *arg4 = (int *) 0 ;
35558 void *argp1 = 0 ;
35559 int res1 = 0 ;
35560 bool temp2 = false ;
35561 int temp3 ;
35562 int res3 = SWIG_TMPOBJ ;
35563 int temp4 ;
35564 int res4 = SWIG_TMPOBJ ;
35565 PyObject * obj0 = 0 ;
35566 PyObject * obj1 = 0 ;
35567 char * kwnames[] = {
35568 (char *) "self",(char *) "string", NULL
35569 };
35570
35571 arg3 = &temp3;
35572 arg4 = &temp4;
35573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35575 if (!SWIG_IsOK(res1)) {
35576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35577 }
35578 arg1 = reinterpret_cast< wxWindow * >(argp1);
35579 {
35580 arg2 = wxString_in_helper(obj1);
35581 if (arg2 == NULL) SWIG_fail;
35582 temp2 = true;
35583 }
35584 {
35585 PyThreadState* __tstate = wxPyBeginAllowThreads();
35586 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35587 wxPyEndAllowThreads(__tstate);
35588 if (PyErr_Occurred()) SWIG_fail;
35589 }
35590 resultobj = SWIG_Py_Void();
35591 if (SWIG_IsTmpObj(res3)) {
35592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35593 } else {
35594 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35596 }
35597 if (SWIG_IsTmpObj(res4)) {
35598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35599 } else {
35600 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35602 }
35603 {
35604 if (temp2)
35605 delete arg2;
35606 }
35607 return resultobj;
35608 fail:
35609 {
35610 if (temp2)
35611 delete arg2;
35612 }
35613 return NULL;
35614 }
35615
35616
35617 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35618 PyObject *resultobj = 0;
35619 wxWindow *arg1 = (wxWindow *) 0 ;
35620 wxString *arg2 = 0 ;
35621 int *arg3 = (int *) 0 ;
35622 int *arg4 = (int *) 0 ;
35623 int *arg5 = (int *) 0 ;
35624 int *arg6 = (int *) 0 ;
35625 wxFont *arg7 = (wxFont *) NULL ;
35626 void *argp1 = 0 ;
35627 int res1 = 0 ;
35628 bool temp2 = false ;
35629 int temp3 ;
35630 int res3 = SWIG_TMPOBJ ;
35631 int temp4 ;
35632 int res4 = SWIG_TMPOBJ ;
35633 int temp5 ;
35634 int res5 = SWIG_TMPOBJ ;
35635 int temp6 ;
35636 int res6 = SWIG_TMPOBJ ;
35637 void *argp7 = 0 ;
35638 int res7 = 0 ;
35639 PyObject * obj0 = 0 ;
35640 PyObject * obj1 = 0 ;
35641 PyObject * obj2 = 0 ;
35642 char * kwnames[] = {
35643 (char *) "self",(char *) "string",(char *) "font", NULL
35644 };
35645
35646 arg3 = &temp3;
35647 arg4 = &temp4;
35648 arg5 = &temp5;
35649 arg6 = &temp6;
35650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35652 if (!SWIG_IsOK(res1)) {
35653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35654 }
35655 arg1 = reinterpret_cast< wxWindow * >(argp1);
35656 {
35657 arg2 = wxString_in_helper(obj1);
35658 if (arg2 == NULL) SWIG_fail;
35659 temp2 = true;
35660 }
35661 if (obj2) {
35662 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35663 if (!SWIG_IsOK(res7)) {
35664 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35665 }
35666 arg7 = reinterpret_cast< wxFont * >(argp7);
35667 }
35668 {
35669 PyThreadState* __tstate = wxPyBeginAllowThreads();
35670 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35671 wxPyEndAllowThreads(__tstate);
35672 if (PyErr_Occurred()) SWIG_fail;
35673 }
35674 resultobj = SWIG_Py_Void();
35675 if (SWIG_IsTmpObj(res3)) {
35676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35677 } else {
35678 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35679 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35680 }
35681 if (SWIG_IsTmpObj(res4)) {
35682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35683 } else {
35684 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35685 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35686 }
35687 if (SWIG_IsTmpObj(res5)) {
35688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35689 } else {
35690 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35692 }
35693 if (SWIG_IsTmpObj(res6)) {
35694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35695 } else {
35696 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35698 }
35699 {
35700 if (temp2)
35701 delete arg2;
35702 }
35703 return resultobj;
35704 fail:
35705 {
35706 if (temp2)
35707 delete arg2;
35708 }
35709 return NULL;
35710 }
35711
35712
35713 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35714 PyObject *resultobj = 0;
35715 wxWindow *arg1 = (wxWindow *) 0 ;
35716 int *arg2 = (int *) 0 ;
35717 int *arg3 = (int *) 0 ;
35718 void *argp1 = 0 ;
35719 int res1 = 0 ;
35720 int temp2 ;
35721 int res2 = 0 ;
35722 int temp3 ;
35723 int res3 = 0 ;
35724 PyObject * obj0 = 0 ;
35725 PyObject * obj1 = 0 ;
35726 PyObject * obj2 = 0 ;
35727 char * kwnames[] = {
35728 (char *) "self",(char *) "x",(char *) "y", NULL
35729 };
35730
35731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35733 if (!SWIG_IsOK(res1)) {
35734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35735 }
35736 arg1 = reinterpret_cast< wxWindow * >(argp1);
35737 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35738 int val;
35739 int ecode = SWIG_AsVal_int(obj1, &val);
35740 if (!SWIG_IsOK(ecode)) {
35741 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35742 }
35743 temp2 = static_cast< int >(val);
35744 arg2 = &temp2;
35745 res2 = SWIG_AddTmpMask(ecode);
35746 }
35747 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35748 int val;
35749 int ecode = SWIG_AsVal_int(obj2, &val);
35750 if (!SWIG_IsOK(ecode)) {
35751 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35752 }
35753 temp3 = static_cast< int >(val);
35754 arg3 = &temp3;
35755 res3 = SWIG_AddTmpMask(ecode);
35756 }
35757 {
35758 PyThreadState* __tstate = wxPyBeginAllowThreads();
35759 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35760 wxPyEndAllowThreads(__tstate);
35761 if (PyErr_Occurred()) SWIG_fail;
35762 }
35763 resultobj = SWIG_Py_Void();
35764 if (SWIG_IsTmpObj(res2)) {
35765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35766 } else {
35767 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35769 }
35770 if (SWIG_IsTmpObj(res3)) {
35771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35772 } else {
35773 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35775 }
35776 return resultobj;
35777 fail:
35778 return NULL;
35779 }
35780
35781
35782 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35783 PyObject *resultobj = 0;
35784 wxWindow *arg1 = (wxWindow *) 0 ;
35785 int *arg2 = (int *) 0 ;
35786 int *arg3 = (int *) 0 ;
35787 void *argp1 = 0 ;
35788 int res1 = 0 ;
35789 int temp2 ;
35790 int res2 = 0 ;
35791 int temp3 ;
35792 int res3 = 0 ;
35793 PyObject * obj0 = 0 ;
35794 PyObject * obj1 = 0 ;
35795 PyObject * obj2 = 0 ;
35796 char * kwnames[] = {
35797 (char *) "self",(char *) "x",(char *) "y", NULL
35798 };
35799
35800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35802 if (!SWIG_IsOK(res1)) {
35803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35804 }
35805 arg1 = reinterpret_cast< wxWindow * >(argp1);
35806 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35807 int val;
35808 int ecode = SWIG_AsVal_int(obj1, &val);
35809 if (!SWIG_IsOK(ecode)) {
35810 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35811 }
35812 temp2 = static_cast< int >(val);
35813 arg2 = &temp2;
35814 res2 = SWIG_AddTmpMask(ecode);
35815 }
35816 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35817 int val;
35818 int ecode = SWIG_AsVal_int(obj2, &val);
35819 if (!SWIG_IsOK(ecode)) {
35820 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35821 }
35822 temp3 = static_cast< int >(val);
35823 arg3 = &temp3;
35824 res3 = SWIG_AddTmpMask(ecode);
35825 }
35826 {
35827 PyThreadState* __tstate = wxPyBeginAllowThreads();
35828 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35829 wxPyEndAllowThreads(__tstate);
35830 if (PyErr_Occurred()) SWIG_fail;
35831 }
35832 resultobj = SWIG_Py_Void();
35833 if (SWIG_IsTmpObj(res2)) {
35834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35835 } else {
35836 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35838 }
35839 if (SWIG_IsTmpObj(res3)) {
35840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35841 } else {
35842 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35844 }
35845 return resultobj;
35846 fail:
35847 return NULL;
35848 }
35849
35850
35851 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35852 PyObject *resultobj = 0;
35853 wxWindow *arg1 = (wxWindow *) 0 ;
35854 wxPoint *arg2 = 0 ;
35855 wxPoint result;
35856 void *argp1 = 0 ;
35857 int res1 = 0 ;
35858 wxPoint temp2 ;
35859 PyObject * obj0 = 0 ;
35860 PyObject * obj1 = 0 ;
35861 char * kwnames[] = {
35862 (char *) "self",(char *) "pt", NULL
35863 };
35864
35865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35867 if (!SWIG_IsOK(res1)) {
35868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35869 }
35870 arg1 = reinterpret_cast< wxWindow * >(argp1);
35871 {
35872 arg2 = &temp2;
35873 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35874 }
35875 {
35876 PyThreadState* __tstate = wxPyBeginAllowThreads();
35877 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35878 wxPyEndAllowThreads(__tstate);
35879 if (PyErr_Occurred()) SWIG_fail;
35880 }
35881 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35882 return resultobj;
35883 fail:
35884 return NULL;
35885 }
35886
35887
35888 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35889 PyObject *resultobj = 0;
35890 wxWindow *arg1 = (wxWindow *) 0 ;
35891 wxPoint *arg2 = 0 ;
35892 wxPoint result;
35893 void *argp1 = 0 ;
35894 int res1 = 0 ;
35895 wxPoint temp2 ;
35896 PyObject * obj0 = 0 ;
35897 PyObject * obj1 = 0 ;
35898 char * kwnames[] = {
35899 (char *) "self",(char *) "pt", NULL
35900 };
35901
35902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35904 if (!SWIG_IsOK(res1)) {
35905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35906 }
35907 arg1 = reinterpret_cast< wxWindow * >(argp1);
35908 {
35909 arg2 = &temp2;
35910 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35911 }
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35915 wxPyEndAllowThreads(__tstate);
35916 if (PyErr_Occurred()) SWIG_fail;
35917 }
35918 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35919 return resultobj;
35920 fail:
35921 return NULL;
35922 }
35923
35924
35925 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35926 PyObject *resultobj = 0;
35927 wxWindow *arg1 = (wxWindow *) 0 ;
35928 int arg2 ;
35929 int arg3 ;
35930 wxHitTest result;
35931 void *argp1 = 0 ;
35932 int res1 = 0 ;
35933 int val2 ;
35934 int ecode2 = 0 ;
35935 int val3 ;
35936 int ecode3 = 0 ;
35937 PyObject * obj0 = 0 ;
35938 PyObject * obj1 = 0 ;
35939 PyObject * obj2 = 0 ;
35940 char * kwnames[] = {
35941 (char *) "self",(char *) "x",(char *) "y", NULL
35942 };
35943
35944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35946 if (!SWIG_IsOK(res1)) {
35947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35948 }
35949 arg1 = reinterpret_cast< wxWindow * >(argp1);
35950 ecode2 = SWIG_AsVal_int(obj1, &val2);
35951 if (!SWIG_IsOK(ecode2)) {
35952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35953 }
35954 arg2 = static_cast< int >(val2);
35955 ecode3 = SWIG_AsVal_int(obj2, &val3);
35956 if (!SWIG_IsOK(ecode3)) {
35957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35958 }
35959 arg3 = static_cast< int >(val3);
35960 {
35961 PyThreadState* __tstate = wxPyBeginAllowThreads();
35962 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35963 wxPyEndAllowThreads(__tstate);
35964 if (PyErr_Occurred()) SWIG_fail;
35965 }
35966 resultobj = SWIG_From_int(static_cast< int >(result));
35967 return resultobj;
35968 fail:
35969 return NULL;
35970 }
35971
35972
35973 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35974 PyObject *resultobj = 0;
35975 wxWindow *arg1 = (wxWindow *) 0 ;
35976 wxPoint *arg2 = 0 ;
35977 wxHitTest result;
35978 void *argp1 = 0 ;
35979 int res1 = 0 ;
35980 wxPoint temp2 ;
35981 PyObject * obj0 = 0 ;
35982 PyObject * obj1 = 0 ;
35983 char * kwnames[] = {
35984 (char *) "self",(char *) "pt", NULL
35985 };
35986
35987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35989 if (!SWIG_IsOK(res1)) {
35990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35991 }
35992 arg1 = reinterpret_cast< wxWindow * >(argp1);
35993 {
35994 arg2 = &temp2;
35995 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35996 }
35997 {
35998 PyThreadState* __tstate = wxPyBeginAllowThreads();
35999 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36000 wxPyEndAllowThreads(__tstate);
36001 if (PyErr_Occurred()) SWIG_fail;
36002 }
36003 resultobj = SWIG_From_int(static_cast< int >(result));
36004 return resultobj;
36005 fail:
36006 return NULL;
36007 }
36008
36009
36010 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36011 PyObject *resultobj = 0;
36012 wxWindow *arg1 = (wxWindow *) 0 ;
36013 long arg2 ;
36014 wxBorder result;
36015 void *argp1 = 0 ;
36016 int res1 = 0 ;
36017 long val2 ;
36018 int ecode2 = 0 ;
36019
36020 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36022 if (!SWIG_IsOK(res1)) {
36023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36024 }
36025 arg1 = reinterpret_cast< wxWindow * >(argp1);
36026 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36027 if (!SWIG_IsOK(ecode2)) {
36028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36029 }
36030 arg2 = static_cast< long >(val2);
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 resultobj = SWIG_From_int(static_cast< int >(result));
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36045 PyObject *resultobj = 0;
36046 wxWindow *arg1 = (wxWindow *) 0 ;
36047 wxBorder result;
36048 void *argp1 = 0 ;
36049 int res1 = 0 ;
36050
36051 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36053 if (!SWIG_IsOK(res1)) {
36054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36055 }
36056 arg1 = reinterpret_cast< wxWindow * >(argp1);
36057 {
36058 PyThreadState* __tstate = wxPyBeginAllowThreads();
36059 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36060 wxPyEndAllowThreads(__tstate);
36061 if (PyErr_Occurred()) SWIG_fail;
36062 }
36063 resultobj = SWIG_From_int(static_cast< int >(result));
36064 return resultobj;
36065 fail:
36066 return NULL;
36067 }
36068
36069
36070 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36071 int argc;
36072 PyObject *argv[3];
36073
36074 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36075 --argc;
36076 if (argc == 1) {
36077 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36078 }
36079 if (argc == 2) {
36080 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36081 }
36082
36083 fail:
36084 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36085 return NULL;
36086 }
36087
36088
36089 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36090 PyObject *resultobj = 0;
36091 wxWindow *arg1 = (wxWindow *) 0 ;
36092 long arg2 = (long) wxUPDATE_UI_NONE ;
36093 void *argp1 = 0 ;
36094 int res1 = 0 ;
36095 long val2 ;
36096 int ecode2 = 0 ;
36097 PyObject * obj0 = 0 ;
36098 PyObject * obj1 = 0 ;
36099 char * kwnames[] = {
36100 (char *) "self",(char *) "flags", NULL
36101 };
36102
36103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36105 if (!SWIG_IsOK(res1)) {
36106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36107 }
36108 arg1 = reinterpret_cast< wxWindow * >(argp1);
36109 if (obj1) {
36110 ecode2 = SWIG_AsVal_long(obj1, &val2);
36111 if (!SWIG_IsOK(ecode2)) {
36112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36113 }
36114 arg2 = static_cast< long >(val2);
36115 }
36116 {
36117 PyThreadState* __tstate = wxPyBeginAllowThreads();
36118 (arg1)->UpdateWindowUI(arg2);
36119 wxPyEndAllowThreads(__tstate);
36120 if (PyErr_Occurred()) SWIG_fail;
36121 }
36122 resultobj = SWIG_Py_Void();
36123 return resultobj;
36124 fail:
36125 return NULL;
36126 }
36127
36128
36129 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36130 PyObject *resultobj = 0;
36131 wxWindow *arg1 = (wxWindow *) 0 ;
36132 wxMenu *arg2 = (wxMenu *) 0 ;
36133 int arg3 = (int) -1 ;
36134 int arg4 = (int) -1 ;
36135 bool result;
36136 void *argp1 = 0 ;
36137 int res1 = 0 ;
36138 void *argp2 = 0 ;
36139 int res2 = 0 ;
36140 int val3 ;
36141 int ecode3 = 0 ;
36142 int val4 ;
36143 int ecode4 = 0 ;
36144 PyObject * obj0 = 0 ;
36145 PyObject * obj1 = 0 ;
36146 PyObject * obj2 = 0 ;
36147 PyObject * obj3 = 0 ;
36148 char * kwnames[] = {
36149 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36150 };
36151
36152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36154 if (!SWIG_IsOK(res1)) {
36155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36156 }
36157 arg1 = reinterpret_cast< wxWindow * >(argp1);
36158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36159 if (!SWIG_IsOK(res2)) {
36160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36161 }
36162 arg2 = reinterpret_cast< wxMenu * >(argp2);
36163 if (obj2) {
36164 ecode3 = SWIG_AsVal_int(obj2, &val3);
36165 if (!SWIG_IsOK(ecode3)) {
36166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36167 }
36168 arg3 = static_cast< int >(val3);
36169 }
36170 if (obj3) {
36171 ecode4 = SWIG_AsVal_int(obj3, &val4);
36172 if (!SWIG_IsOK(ecode4)) {
36173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36174 }
36175 arg4 = static_cast< int >(val4);
36176 }
36177 {
36178 PyThreadState* __tstate = wxPyBeginAllowThreads();
36179 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36180 wxPyEndAllowThreads(__tstate);
36181 if (PyErr_Occurred()) SWIG_fail;
36182 }
36183 {
36184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36185 }
36186 return resultobj;
36187 fail:
36188 return NULL;
36189 }
36190
36191
36192 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36193 PyObject *resultobj = 0;
36194 wxWindow *arg1 = (wxWindow *) 0 ;
36195 wxMenu *arg2 = (wxMenu *) 0 ;
36196 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36197 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36198 bool result;
36199 void *argp1 = 0 ;
36200 int res1 = 0 ;
36201 void *argp2 = 0 ;
36202 int res2 = 0 ;
36203 wxPoint temp3 ;
36204 PyObject * obj0 = 0 ;
36205 PyObject * obj1 = 0 ;
36206 PyObject * obj2 = 0 ;
36207 char * kwnames[] = {
36208 (char *) "self",(char *) "menu",(char *) "pos", NULL
36209 };
36210
36211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36213 if (!SWIG_IsOK(res1)) {
36214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36215 }
36216 arg1 = reinterpret_cast< wxWindow * >(argp1);
36217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36218 if (!SWIG_IsOK(res2)) {
36219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36220 }
36221 arg2 = reinterpret_cast< wxMenu * >(argp2);
36222 if (obj2) {
36223 {
36224 arg3 = &temp3;
36225 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36226 }
36227 }
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36231 wxPyEndAllowThreads(__tstate);
36232 if (PyErr_Occurred()) SWIG_fail;
36233 }
36234 {
36235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36236 }
36237 return resultobj;
36238 fail:
36239 return NULL;
36240 }
36241
36242
36243 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36244 PyObject *resultobj = 0;
36245 wxWindow *arg1 = (wxWindow *) 0 ;
36246 long result;
36247 void *argp1 = 0 ;
36248 int res1 = 0 ;
36249 PyObject *swig_obj[1] ;
36250
36251 if (!args) SWIG_fail;
36252 swig_obj[0] = args;
36253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36254 if (!SWIG_IsOK(res1)) {
36255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36256 }
36257 arg1 = reinterpret_cast< wxWindow * >(argp1);
36258 {
36259 PyThreadState* __tstate = wxPyBeginAllowThreads();
36260 result = (long)wxWindow_GetHandle(arg1);
36261 wxPyEndAllowThreads(__tstate);
36262 if (PyErr_Occurred()) SWIG_fail;
36263 }
36264 resultobj = SWIG_From_long(static_cast< long >(result));
36265 return resultobj;
36266 fail:
36267 return NULL;
36268 }
36269
36270
36271 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36272 PyObject *resultobj = 0;
36273 wxWindow *arg1 = (wxWindow *) 0 ;
36274 long arg2 ;
36275 void *argp1 = 0 ;
36276 int res1 = 0 ;
36277 long val2 ;
36278 int ecode2 = 0 ;
36279 PyObject * obj0 = 0 ;
36280 PyObject * obj1 = 0 ;
36281 char * kwnames[] = {
36282 (char *) "self",(char *) "handle", NULL
36283 };
36284
36285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36287 if (!SWIG_IsOK(res1)) {
36288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36289 }
36290 arg1 = reinterpret_cast< wxWindow * >(argp1);
36291 ecode2 = SWIG_AsVal_long(obj1, &val2);
36292 if (!SWIG_IsOK(ecode2)) {
36293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36294 }
36295 arg2 = static_cast< long >(val2);
36296 {
36297 PyThreadState* __tstate = wxPyBeginAllowThreads();
36298 wxWindow_AssociateHandle(arg1,arg2);
36299 wxPyEndAllowThreads(__tstate);
36300 if (PyErr_Occurred()) SWIG_fail;
36301 }
36302 resultobj = SWIG_Py_Void();
36303 return resultobj;
36304 fail:
36305 return NULL;
36306 }
36307
36308
36309 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36310 PyObject *resultobj = 0;
36311 wxWindow *arg1 = (wxWindow *) 0 ;
36312 void *argp1 = 0 ;
36313 int res1 = 0 ;
36314 PyObject *swig_obj[1] ;
36315
36316 if (!args) SWIG_fail;
36317 swig_obj[0] = args;
36318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36319 if (!SWIG_IsOK(res1)) {
36320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36321 }
36322 arg1 = reinterpret_cast< wxWindow * >(argp1);
36323 {
36324 PyThreadState* __tstate = wxPyBeginAllowThreads();
36325 (arg1)->DissociateHandle();
36326 wxPyEndAllowThreads(__tstate);
36327 if (PyErr_Occurred()) SWIG_fail;
36328 }
36329 resultobj = SWIG_Py_Void();
36330 return resultobj;
36331 fail:
36332 return NULL;
36333 }
36334
36335
36336 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36337 PyObject *resultobj = 0;
36338 wxWindow *arg1 = (wxWindow *) 0 ;
36339 wxPaintEvent *arg2 = 0 ;
36340 void *argp1 = 0 ;
36341 int res1 = 0 ;
36342 void *argp2 = 0 ;
36343 int res2 = 0 ;
36344 PyObject * obj0 = 0 ;
36345 PyObject * obj1 = 0 ;
36346 char * kwnames[] = {
36347 (char *) "self",(char *) "event", NULL
36348 };
36349
36350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36352 if (!SWIG_IsOK(res1)) {
36353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36354 }
36355 arg1 = reinterpret_cast< wxWindow * >(argp1);
36356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36357 if (!SWIG_IsOK(res2)) {
36358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36359 }
36360 if (!argp2) {
36361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36362 }
36363 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36364 {
36365 PyThreadState* __tstate = wxPyBeginAllowThreads();
36366 (arg1)->OnPaint(*arg2);
36367 wxPyEndAllowThreads(__tstate);
36368 if (PyErr_Occurred()) SWIG_fail;
36369 }
36370 resultobj = SWIG_Py_Void();
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36378 PyObject *resultobj = 0;
36379 wxWindow *arg1 = (wxWindow *) 0 ;
36380 int arg2 ;
36381 bool result;
36382 void *argp1 = 0 ;
36383 int res1 = 0 ;
36384 int val2 ;
36385 int ecode2 = 0 ;
36386 PyObject * obj0 = 0 ;
36387 PyObject * obj1 = 0 ;
36388 char * kwnames[] = {
36389 (char *) "self",(char *) "orient", NULL
36390 };
36391
36392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36394 if (!SWIG_IsOK(res1)) {
36395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36396 }
36397 arg1 = reinterpret_cast< wxWindow * >(argp1);
36398 ecode2 = SWIG_AsVal_int(obj1, &val2);
36399 if (!SWIG_IsOK(ecode2)) {
36400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36401 }
36402 arg2 = static_cast< int >(val2);
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36406 wxPyEndAllowThreads(__tstate);
36407 if (PyErr_Occurred()) SWIG_fail;
36408 }
36409 {
36410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36411 }
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj = 0;
36420 wxWindow *arg1 = (wxWindow *) 0 ;
36421 int arg2 ;
36422 int arg3 ;
36423 int arg4 ;
36424 int arg5 ;
36425 bool arg6 = (bool) true ;
36426 void *argp1 = 0 ;
36427 int res1 = 0 ;
36428 int val2 ;
36429 int ecode2 = 0 ;
36430 int val3 ;
36431 int ecode3 = 0 ;
36432 int val4 ;
36433 int ecode4 = 0 ;
36434 int val5 ;
36435 int ecode5 = 0 ;
36436 bool val6 ;
36437 int ecode6 = 0 ;
36438 PyObject * obj0 = 0 ;
36439 PyObject * obj1 = 0 ;
36440 PyObject * obj2 = 0 ;
36441 PyObject * obj3 = 0 ;
36442 PyObject * obj4 = 0 ;
36443 PyObject * obj5 = 0 ;
36444 char * kwnames[] = {
36445 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36446 };
36447
36448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36450 if (!SWIG_IsOK(res1)) {
36451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36452 }
36453 arg1 = reinterpret_cast< wxWindow * >(argp1);
36454 ecode2 = SWIG_AsVal_int(obj1, &val2);
36455 if (!SWIG_IsOK(ecode2)) {
36456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36457 }
36458 arg2 = static_cast< int >(val2);
36459 ecode3 = SWIG_AsVal_int(obj2, &val3);
36460 if (!SWIG_IsOK(ecode3)) {
36461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36462 }
36463 arg3 = static_cast< int >(val3);
36464 ecode4 = SWIG_AsVal_int(obj3, &val4);
36465 if (!SWIG_IsOK(ecode4)) {
36466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36467 }
36468 arg4 = static_cast< int >(val4);
36469 ecode5 = SWIG_AsVal_int(obj4, &val5);
36470 if (!SWIG_IsOK(ecode5)) {
36471 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36472 }
36473 arg5 = static_cast< int >(val5);
36474 if (obj5) {
36475 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36476 if (!SWIG_IsOK(ecode6)) {
36477 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36478 }
36479 arg6 = static_cast< bool >(val6);
36480 }
36481 {
36482 PyThreadState* __tstate = wxPyBeginAllowThreads();
36483 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36484 wxPyEndAllowThreads(__tstate);
36485 if (PyErr_Occurred()) SWIG_fail;
36486 }
36487 resultobj = SWIG_Py_Void();
36488 return resultobj;
36489 fail:
36490 return NULL;
36491 }
36492
36493
36494 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36495 PyObject *resultobj = 0;
36496 wxWindow *arg1 = (wxWindow *) 0 ;
36497 int arg2 ;
36498 int arg3 ;
36499 bool arg4 = (bool) true ;
36500 void *argp1 = 0 ;
36501 int res1 = 0 ;
36502 int val2 ;
36503 int ecode2 = 0 ;
36504 int val3 ;
36505 int ecode3 = 0 ;
36506 bool val4 ;
36507 int ecode4 = 0 ;
36508 PyObject * obj0 = 0 ;
36509 PyObject * obj1 = 0 ;
36510 PyObject * obj2 = 0 ;
36511 PyObject * obj3 = 0 ;
36512 char * kwnames[] = {
36513 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36514 };
36515
36516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36518 if (!SWIG_IsOK(res1)) {
36519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36520 }
36521 arg1 = reinterpret_cast< wxWindow * >(argp1);
36522 ecode2 = SWIG_AsVal_int(obj1, &val2);
36523 if (!SWIG_IsOK(ecode2)) {
36524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36525 }
36526 arg2 = static_cast< int >(val2);
36527 ecode3 = SWIG_AsVal_int(obj2, &val3);
36528 if (!SWIG_IsOK(ecode3)) {
36529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36530 }
36531 arg3 = static_cast< int >(val3);
36532 if (obj3) {
36533 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36534 if (!SWIG_IsOK(ecode4)) {
36535 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36536 }
36537 arg4 = static_cast< bool >(val4);
36538 }
36539 {
36540 PyThreadState* __tstate = wxPyBeginAllowThreads();
36541 (arg1)->SetScrollPos(arg2,arg3,arg4);
36542 wxPyEndAllowThreads(__tstate);
36543 if (PyErr_Occurred()) SWIG_fail;
36544 }
36545 resultobj = SWIG_Py_Void();
36546 return resultobj;
36547 fail:
36548 return NULL;
36549 }
36550
36551
36552 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36553 PyObject *resultobj = 0;
36554 wxWindow *arg1 = (wxWindow *) 0 ;
36555 int arg2 ;
36556 int result;
36557 void *argp1 = 0 ;
36558 int res1 = 0 ;
36559 int val2 ;
36560 int ecode2 = 0 ;
36561 PyObject * obj0 = 0 ;
36562 PyObject * obj1 = 0 ;
36563 char * kwnames[] = {
36564 (char *) "self",(char *) "orientation", NULL
36565 };
36566
36567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36569 if (!SWIG_IsOK(res1)) {
36570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36571 }
36572 arg1 = reinterpret_cast< wxWindow * >(argp1);
36573 ecode2 = SWIG_AsVal_int(obj1, &val2);
36574 if (!SWIG_IsOK(ecode2)) {
36575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36576 }
36577 arg2 = static_cast< int >(val2);
36578 {
36579 PyThreadState* __tstate = wxPyBeginAllowThreads();
36580 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36581 wxPyEndAllowThreads(__tstate);
36582 if (PyErr_Occurred()) SWIG_fail;
36583 }
36584 resultobj = SWIG_From_int(static_cast< int >(result));
36585 return resultobj;
36586 fail:
36587 return NULL;
36588 }
36589
36590
36591 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36592 PyObject *resultobj = 0;
36593 wxWindow *arg1 = (wxWindow *) 0 ;
36594 int arg2 ;
36595 int result;
36596 void *argp1 = 0 ;
36597 int res1 = 0 ;
36598 int val2 ;
36599 int ecode2 = 0 ;
36600 PyObject * obj0 = 0 ;
36601 PyObject * obj1 = 0 ;
36602 char * kwnames[] = {
36603 (char *) "self",(char *) "orientation", NULL
36604 };
36605
36606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36608 if (!SWIG_IsOK(res1)) {
36609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36610 }
36611 arg1 = reinterpret_cast< wxWindow * >(argp1);
36612 ecode2 = SWIG_AsVal_int(obj1, &val2);
36613 if (!SWIG_IsOK(ecode2)) {
36614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36615 }
36616 arg2 = static_cast< int >(val2);
36617 {
36618 PyThreadState* __tstate = wxPyBeginAllowThreads();
36619 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36620 wxPyEndAllowThreads(__tstate);
36621 if (PyErr_Occurred()) SWIG_fail;
36622 }
36623 resultobj = SWIG_From_int(static_cast< int >(result));
36624 return resultobj;
36625 fail:
36626 return NULL;
36627 }
36628
36629
36630 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36631 PyObject *resultobj = 0;
36632 wxWindow *arg1 = (wxWindow *) 0 ;
36633 int arg2 ;
36634 int result;
36635 void *argp1 = 0 ;
36636 int res1 = 0 ;
36637 int val2 ;
36638 int ecode2 = 0 ;
36639 PyObject * obj0 = 0 ;
36640 PyObject * obj1 = 0 ;
36641 char * kwnames[] = {
36642 (char *) "self",(char *) "orientation", NULL
36643 };
36644
36645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36647 if (!SWIG_IsOK(res1)) {
36648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36649 }
36650 arg1 = reinterpret_cast< wxWindow * >(argp1);
36651 ecode2 = SWIG_AsVal_int(obj1, &val2);
36652 if (!SWIG_IsOK(ecode2)) {
36653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36654 }
36655 arg2 = static_cast< int >(val2);
36656 {
36657 PyThreadState* __tstate = wxPyBeginAllowThreads();
36658 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36659 wxPyEndAllowThreads(__tstate);
36660 if (PyErr_Occurred()) SWIG_fail;
36661 }
36662 resultobj = SWIG_From_int(static_cast< int >(result));
36663 return resultobj;
36664 fail:
36665 return NULL;
36666 }
36667
36668
36669 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36670 PyObject *resultobj = 0;
36671 wxWindow *arg1 = (wxWindow *) 0 ;
36672 int arg2 ;
36673 int arg3 ;
36674 wxRect *arg4 = (wxRect *) NULL ;
36675 void *argp1 = 0 ;
36676 int res1 = 0 ;
36677 int val2 ;
36678 int ecode2 = 0 ;
36679 int val3 ;
36680 int ecode3 = 0 ;
36681 void *argp4 = 0 ;
36682 int res4 = 0 ;
36683 PyObject * obj0 = 0 ;
36684 PyObject * obj1 = 0 ;
36685 PyObject * obj2 = 0 ;
36686 PyObject * obj3 = 0 ;
36687 char * kwnames[] = {
36688 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36689 };
36690
36691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36693 if (!SWIG_IsOK(res1)) {
36694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36695 }
36696 arg1 = reinterpret_cast< wxWindow * >(argp1);
36697 ecode2 = SWIG_AsVal_int(obj1, &val2);
36698 if (!SWIG_IsOK(ecode2)) {
36699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36700 }
36701 arg2 = static_cast< int >(val2);
36702 ecode3 = SWIG_AsVal_int(obj2, &val3);
36703 if (!SWIG_IsOK(ecode3)) {
36704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36705 }
36706 arg3 = static_cast< int >(val3);
36707 if (obj3) {
36708 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36709 if (!SWIG_IsOK(res4)) {
36710 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36711 }
36712 arg4 = reinterpret_cast< wxRect * >(argp4);
36713 }
36714 {
36715 PyThreadState* __tstate = wxPyBeginAllowThreads();
36716 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36717 wxPyEndAllowThreads(__tstate);
36718 if (PyErr_Occurred()) SWIG_fail;
36719 }
36720 resultobj = SWIG_Py_Void();
36721 return resultobj;
36722 fail:
36723 return NULL;
36724 }
36725
36726
36727 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36728 PyObject *resultobj = 0;
36729 wxWindow *arg1 = (wxWindow *) 0 ;
36730 int arg2 ;
36731 bool result;
36732 void *argp1 = 0 ;
36733 int res1 = 0 ;
36734 int val2 ;
36735 int ecode2 = 0 ;
36736 PyObject * obj0 = 0 ;
36737 PyObject * obj1 = 0 ;
36738 char * kwnames[] = {
36739 (char *) "self",(char *) "lines", NULL
36740 };
36741
36742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36744 if (!SWIG_IsOK(res1)) {
36745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36746 }
36747 arg1 = reinterpret_cast< wxWindow * >(argp1);
36748 ecode2 = SWIG_AsVal_int(obj1, &val2);
36749 if (!SWIG_IsOK(ecode2)) {
36750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36751 }
36752 arg2 = static_cast< int >(val2);
36753 {
36754 PyThreadState* __tstate = wxPyBeginAllowThreads();
36755 result = (bool)(arg1)->ScrollLines(arg2);
36756 wxPyEndAllowThreads(__tstate);
36757 if (PyErr_Occurred()) SWIG_fail;
36758 }
36759 {
36760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36761 }
36762 return resultobj;
36763 fail:
36764 return NULL;
36765 }
36766
36767
36768 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36769 PyObject *resultobj = 0;
36770 wxWindow *arg1 = (wxWindow *) 0 ;
36771 int arg2 ;
36772 bool result;
36773 void *argp1 = 0 ;
36774 int res1 = 0 ;
36775 int val2 ;
36776 int ecode2 = 0 ;
36777 PyObject * obj0 = 0 ;
36778 PyObject * obj1 = 0 ;
36779 char * kwnames[] = {
36780 (char *) "self",(char *) "pages", NULL
36781 };
36782
36783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36785 if (!SWIG_IsOK(res1)) {
36786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36787 }
36788 arg1 = reinterpret_cast< wxWindow * >(argp1);
36789 ecode2 = SWIG_AsVal_int(obj1, &val2);
36790 if (!SWIG_IsOK(ecode2)) {
36791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36792 }
36793 arg2 = static_cast< int >(val2);
36794 {
36795 PyThreadState* __tstate = wxPyBeginAllowThreads();
36796 result = (bool)(arg1)->ScrollPages(arg2);
36797 wxPyEndAllowThreads(__tstate);
36798 if (PyErr_Occurred()) SWIG_fail;
36799 }
36800 {
36801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36802 }
36803 return resultobj;
36804 fail:
36805 return NULL;
36806 }
36807
36808
36809 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36810 PyObject *resultobj = 0;
36811 wxWindow *arg1 = (wxWindow *) 0 ;
36812 bool result;
36813 void *argp1 = 0 ;
36814 int res1 = 0 ;
36815 PyObject *swig_obj[1] ;
36816
36817 if (!args) SWIG_fail;
36818 swig_obj[0] = args;
36819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36820 if (!SWIG_IsOK(res1)) {
36821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36822 }
36823 arg1 = reinterpret_cast< wxWindow * >(argp1);
36824 {
36825 PyThreadState* __tstate = wxPyBeginAllowThreads();
36826 result = (bool)(arg1)->LineUp();
36827 wxPyEndAllowThreads(__tstate);
36828 if (PyErr_Occurred()) SWIG_fail;
36829 }
36830 {
36831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36832 }
36833 return resultobj;
36834 fail:
36835 return NULL;
36836 }
36837
36838
36839 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36840 PyObject *resultobj = 0;
36841 wxWindow *arg1 = (wxWindow *) 0 ;
36842 bool result;
36843 void *argp1 = 0 ;
36844 int res1 = 0 ;
36845 PyObject *swig_obj[1] ;
36846
36847 if (!args) SWIG_fail;
36848 swig_obj[0] = args;
36849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36850 if (!SWIG_IsOK(res1)) {
36851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36852 }
36853 arg1 = reinterpret_cast< wxWindow * >(argp1);
36854 {
36855 PyThreadState* __tstate = wxPyBeginAllowThreads();
36856 result = (bool)(arg1)->LineDown();
36857 wxPyEndAllowThreads(__tstate);
36858 if (PyErr_Occurred()) SWIG_fail;
36859 }
36860 {
36861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36862 }
36863 return resultobj;
36864 fail:
36865 return NULL;
36866 }
36867
36868
36869 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36870 PyObject *resultobj = 0;
36871 wxWindow *arg1 = (wxWindow *) 0 ;
36872 bool result;
36873 void *argp1 = 0 ;
36874 int res1 = 0 ;
36875 PyObject *swig_obj[1] ;
36876
36877 if (!args) SWIG_fail;
36878 swig_obj[0] = args;
36879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36880 if (!SWIG_IsOK(res1)) {
36881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36882 }
36883 arg1 = reinterpret_cast< wxWindow * >(argp1);
36884 {
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 result = (bool)(arg1)->PageUp();
36887 wxPyEndAllowThreads(__tstate);
36888 if (PyErr_Occurred()) SWIG_fail;
36889 }
36890 {
36891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36892 }
36893 return resultobj;
36894 fail:
36895 return NULL;
36896 }
36897
36898
36899 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36900 PyObject *resultobj = 0;
36901 wxWindow *arg1 = (wxWindow *) 0 ;
36902 bool result;
36903 void *argp1 = 0 ;
36904 int res1 = 0 ;
36905 PyObject *swig_obj[1] ;
36906
36907 if (!args) SWIG_fail;
36908 swig_obj[0] = args;
36909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36910 if (!SWIG_IsOK(res1)) {
36911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36912 }
36913 arg1 = reinterpret_cast< wxWindow * >(argp1);
36914 {
36915 PyThreadState* __tstate = wxPyBeginAllowThreads();
36916 result = (bool)(arg1)->PageDown();
36917 wxPyEndAllowThreads(__tstate);
36918 if (PyErr_Occurred()) SWIG_fail;
36919 }
36920 {
36921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36922 }
36923 return resultobj;
36924 fail:
36925 return NULL;
36926 }
36927
36928
36929 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36930 PyObject *resultobj = 0;
36931 wxWindow *arg1 = (wxWindow *) 0 ;
36932 wxString *arg2 = 0 ;
36933 void *argp1 = 0 ;
36934 int res1 = 0 ;
36935 bool temp2 = false ;
36936 PyObject * obj0 = 0 ;
36937 PyObject * obj1 = 0 ;
36938 char * kwnames[] = {
36939 (char *) "self",(char *) "text", NULL
36940 };
36941
36942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36944 if (!SWIG_IsOK(res1)) {
36945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36946 }
36947 arg1 = reinterpret_cast< wxWindow * >(argp1);
36948 {
36949 arg2 = wxString_in_helper(obj1);
36950 if (arg2 == NULL) SWIG_fail;
36951 temp2 = true;
36952 }
36953 {
36954 PyThreadState* __tstate = wxPyBeginAllowThreads();
36955 (arg1)->SetHelpText((wxString const &)*arg2);
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 resultobj = SWIG_Py_Void();
36960 {
36961 if (temp2)
36962 delete arg2;
36963 }
36964 return resultobj;
36965 fail:
36966 {
36967 if (temp2)
36968 delete arg2;
36969 }
36970 return NULL;
36971 }
36972
36973
36974 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36975 PyObject *resultobj = 0;
36976 wxWindow *arg1 = (wxWindow *) 0 ;
36977 wxString *arg2 = 0 ;
36978 void *argp1 = 0 ;
36979 int res1 = 0 ;
36980 bool temp2 = false ;
36981 PyObject * obj0 = 0 ;
36982 PyObject * obj1 = 0 ;
36983 char * kwnames[] = {
36984 (char *) "self",(char *) "text", NULL
36985 };
36986
36987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36989 if (!SWIG_IsOK(res1)) {
36990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36991 }
36992 arg1 = reinterpret_cast< wxWindow * >(argp1);
36993 {
36994 arg2 = wxString_in_helper(obj1);
36995 if (arg2 == NULL) SWIG_fail;
36996 temp2 = true;
36997 }
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 resultobj = SWIG_Py_Void();
37005 {
37006 if (temp2)
37007 delete arg2;
37008 }
37009 return resultobj;
37010 fail:
37011 {
37012 if (temp2)
37013 delete arg2;
37014 }
37015 return NULL;
37016 }
37017
37018
37019 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37020 PyObject *resultobj = 0;
37021 wxWindow *arg1 = (wxWindow *) 0 ;
37022 wxPoint *arg2 = 0 ;
37023 wxHelpEvent::Origin arg3 ;
37024 wxString result;
37025 void *argp1 = 0 ;
37026 int res1 = 0 ;
37027 wxPoint temp2 ;
37028 void *argp3 ;
37029 int res3 = 0 ;
37030 PyObject * obj0 = 0 ;
37031 PyObject * obj1 = 0 ;
37032 PyObject * obj2 = 0 ;
37033 char * kwnames[] = {
37034 (char *) "self",(char *) "pt",(char *) "origin", NULL
37035 };
37036
37037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37039 if (!SWIG_IsOK(res1)) {
37040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37041 }
37042 arg1 = reinterpret_cast< wxWindow * >(argp1);
37043 {
37044 arg2 = &temp2;
37045 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37046 }
37047 {
37048 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37049 if (!SWIG_IsOK(res3)) {
37050 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37051 }
37052 if (!argp3) {
37053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37054 } else {
37055 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37056 arg3 = *temp;
37057 if (SWIG_IsNewObj(res3)) delete temp;
37058 }
37059 }
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37063 wxPyEndAllowThreads(__tstate);
37064 if (PyErr_Occurred()) SWIG_fail;
37065 }
37066 {
37067 #if wxUSE_UNICODE
37068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37069 #else
37070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37071 #endif
37072 }
37073 return resultobj;
37074 fail:
37075 return NULL;
37076 }
37077
37078
37079 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37080 PyObject *resultobj = 0;
37081 wxWindow *arg1 = (wxWindow *) 0 ;
37082 wxString result;
37083 void *argp1 = 0 ;
37084 int res1 = 0 ;
37085 PyObject *swig_obj[1] ;
37086
37087 if (!args) SWIG_fail;
37088 swig_obj[0] = args;
37089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37090 if (!SWIG_IsOK(res1)) {
37091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37092 }
37093 arg1 = reinterpret_cast< wxWindow * >(argp1);
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 result = ((wxWindow const *)arg1)->GetHelpText();
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 {
37101 #if wxUSE_UNICODE
37102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37103 #else
37104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37105 #endif
37106 }
37107 return resultobj;
37108 fail:
37109 return NULL;
37110 }
37111
37112
37113 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37114 PyObject *resultobj = 0;
37115 wxWindow *arg1 = (wxWindow *) 0 ;
37116 wxString *arg2 = 0 ;
37117 void *argp1 = 0 ;
37118 int res1 = 0 ;
37119 bool temp2 = false ;
37120 PyObject * obj0 = 0 ;
37121 PyObject * obj1 = 0 ;
37122 char * kwnames[] = {
37123 (char *) "self",(char *) "tip", NULL
37124 };
37125
37126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37128 if (!SWIG_IsOK(res1)) {
37129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37130 }
37131 arg1 = reinterpret_cast< wxWindow * >(argp1);
37132 {
37133 arg2 = wxString_in_helper(obj1);
37134 if (arg2 == NULL) SWIG_fail;
37135 temp2 = true;
37136 }
37137 {
37138 PyThreadState* __tstate = wxPyBeginAllowThreads();
37139 (arg1)->SetToolTip((wxString const &)*arg2);
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 resultobj = SWIG_Py_Void();
37144 {
37145 if (temp2)
37146 delete arg2;
37147 }
37148 return resultobj;
37149 fail:
37150 {
37151 if (temp2)
37152 delete arg2;
37153 }
37154 return NULL;
37155 }
37156
37157
37158 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37159 PyObject *resultobj = 0;
37160 wxWindow *arg1 = (wxWindow *) 0 ;
37161 wxToolTip *arg2 = (wxToolTip *) 0 ;
37162 void *argp1 = 0 ;
37163 int res1 = 0 ;
37164 int res2 = 0 ;
37165 PyObject * obj0 = 0 ;
37166 PyObject * obj1 = 0 ;
37167 char * kwnames[] = {
37168 (char *) "self",(char *) "tip", NULL
37169 };
37170
37171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37173 if (!SWIG_IsOK(res1)) {
37174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37175 }
37176 arg1 = reinterpret_cast< wxWindow * >(argp1);
37177 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37178 if (!SWIG_IsOK(res2)) {
37179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37180 }
37181 {
37182 PyThreadState* __tstate = wxPyBeginAllowThreads();
37183 (arg1)->SetToolTip(arg2);
37184 wxPyEndAllowThreads(__tstate);
37185 if (PyErr_Occurred()) SWIG_fail;
37186 }
37187 resultobj = SWIG_Py_Void();
37188 return resultobj;
37189 fail:
37190 return NULL;
37191 }
37192
37193
37194 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37195 PyObject *resultobj = 0;
37196 wxWindow *arg1 = (wxWindow *) 0 ;
37197 wxToolTip *result = 0 ;
37198 void *argp1 = 0 ;
37199 int res1 = 0 ;
37200 PyObject *swig_obj[1] ;
37201
37202 if (!args) SWIG_fail;
37203 swig_obj[0] = args;
37204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37205 if (!SWIG_IsOK(res1)) {
37206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37207 }
37208 arg1 = reinterpret_cast< wxWindow * >(argp1);
37209 {
37210 PyThreadState* __tstate = wxPyBeginAllowThreads();
37211 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37212 wxPyEndAllowThreads(__tstate);
37213 if (PyErr_Occurred()) SWIG_fail;
37214 }
37215 {
37216 resultobj = wxPyMake_wxObject(result, (bool)0);
37217 }
37218 return resultobj;
37219 fail:
37220 return NULL;
37221 }
37222
37223
37224 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37225 PyObject *resultobj = 0;
37226 wxWindow *arg1 = (wxWindow *) 0 ;
37227 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37228 void *argp1 = 0 ;
37229 int res1 = 0 ;
37230 int res2 = 0 ;
37231 PyObject * obj0 = 0 ;
37232 PyObject * obj1 = 0 ;
37233 char * kwnames[] = {
37234 (char *) "self",(char *) "dropTarget", NULL
37235 };
37236
37237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37239 if (!SWIG_IsOK(res1)) {
37240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37241 }
37242 arg1 = reinterpret_cast< wxWindow * >(argp1);
37243 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37244 if (!SWIG_IsOK(res2)) {
37245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37246 }
37247 {
37248 PyThreadState* __tstate = wxPyBeginAllowThreads();
37249 (arg1)->SetDropTarget(arg2);
37250 wxPyEndAllowThreads(__tstate);
37251 if (PyErr_Occurred()) SWIG_fail;
37252 }
37253 resultobj = SWIG_Py_Void();
37254 return resultobj;
37255 fail:
37256 return NULL;
37257 }
37258
37259
37260 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37261 PyObject *resultobj = 0;
37262 wxWindow *arg1 = (wxWindow *) 0 ;
37263 wxPyDropTarget *result = 0 ;
37264 void *argp1 = 0 ;
37265 int res1 = 0 ;
37266 PyObject *swig_obj[1] ;
37267
37268 if (!args) SWIG_fail;
37269 swig_obj[0] = args;
37270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37271 if (!SWIG_IsOK(res1)) {
37272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37273 }
37274 arg1 = reinterpret_cast< wxWindow * >(argp1);
37275 {
37276 PyThreadState* __tstate = wxPyBeginAllowThreads();
37277 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37278 wxPyEndAllowThreads(__tstate);
37279 if (PyErr_Occurred()) SWIG_fail;
37280 }
37281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37282 return resultobj;
37283 fail:
37284 return NULL;
37285 }
37286
37287
37288 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37289 PyObject *resultobj = 0;
37290 wxWindow *arg1 = (wxWindow *) 0 ;
37291 bool arg2 ;
37292 void *argp1 = 0 ;
37293 int res1 = 0 ;
37294 bool val2 ;
37295 int ecode2 = 0 ;
37296 PyObject * obj0 = 0 ;
37297 PyObject * obj1 = 0 ;
37298 char * kwnames[] = {
37299 (char *) "self",(char *) "accept", NULL
37300 };
37301
37302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37304 if (!SWIG_IsOK(res1)) {
37305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37306 }
37307 arg1 = reinterpret_cast< wxWindow * >(argp1);
37308 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37309 if (!SWIG_IsOK(ecode2)) {
37310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37311 }
37312 arg2 = static_cast< bool >(val2);
37313 {
37314 PyThreadState* __tstate = wxPyBeginAllowThreads();
37315 (arg1)->DragAcceptFiles(arg2);
37316 wxPyEndAllowThreads(__tstate);
37317 if (PyErr_Occurred()) SWIG_fail;
37318 }
37319 resultobj = SWIG_Py_Void();
37320 return resultobj;
37321 fail:
37322 return NULL;
37323 }
37324
37325
37326 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37327 PyObject *resultobj = 0;
37328 wxWindow *arg1 = (wxWindow *) 0 ;
37329 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37330 void *argp1 = 0 ;
37331 int res1 = 0 ;
37332 int res2 = 0 ;
37333 PyObject * obj0 = 0 ;
37334 PyObject * obj1 = 0 ;
37335 char * kwnames[] = {
37336 (char *) "self",(char *) "constraints", NULL
37337 };
37338
37339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37341 if (!SWIG_IsOK(res1)) {
37342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37343 }
37344 arg1 = reinterpret_cast< wxWindow * >(argp1);
37345 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37346 if (!SWIG_IsOK(res2)) {
37347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37348 }
37349 {
37350 PyThreadState* __tstate = wxPyBeginAllowThreads();
37351 (arg1)->SetConstraints(arg2);
37352 wxPyEndAllowThreads(__tstate);
37353 if (PyErr_Occurred()) SWIG_fail;
37354 }
37355 resultobj = SWIG_Py_Void();
37356 return resultobj;
37357 fail:
37358 return NULL;
37359 }
37360
37361
37362 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37363 PyObject *resultobj = 0;
37364 wxWindow *arg1 = (wxWindow *) 0 ;
37365 wxLayoutConstraints *result = 0 ;
37366 void *argp1 = 0 ;
37367 int res1 = 0 ;
37368 PyObject *swig_obj[1] ;
37369
37370 if (!args) SWIG_fail;
37371 swig_obj[0] = args;
37372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37373 if (!SWIG_IsOK(res1)) {
37374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37375 }
37376 arg1 = reinterpret_cast< wxWindow * >(argp1);
37377 {
37378 PyThreadState* __tstate = wxPyBeginAllowThreads();
37379 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37380 wxPyEndAllowThreads(__tstate);
37381 if (PyErr_Occurred()) SWIG_fail;
37382 }
37383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37384 return resultobj;
37385 fail:
37386 return NULL;
37387 }
37388
37389
37390 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37391 PyObject *resultobj = 0;
37392 wxWindow *arg1 = (wxWindow *) 0 ;
37393 bool arg2 ;
37394 void *argp1 = 0 ;
37395 int res1 = 0 ;
37396 bool val2 ;
37397 int ecode2 = 0 ;
37398 PyObject * obj0 = 0 ;
37399 PyObject * obj1 = 0 ;
37400 char * kwnames[] = {
37401 (char *) "self",(char *) "autoLayout", NULL
37402 };
37403
37404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37406 if (!SWIG_IsOK(res1)) {
37407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37408 }
37409 arg1 = reinterpret_cast< wxWindow * >(argp1);
37410 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37411 if (!SWIG_IsOK(ecode2)) {
37412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37413 }
37414 arg2 = static_cast< bool >(val2);
37415 {
37416 PyThreadState* __tstate = wxPyBeginAllowThreads();
37417 (arg1)->SetAutoLayout(arg2);
37418 wxPyEndAllowThreads(__tstate);
37419 if (PyErr_Occurred()) SWIG_fail;
37420 }
37421 resultobj = SWIG_Py_Void();
37422 return resultobj;
37423 fail:
37424 return NULL;
37425 }
37426
37427
37428 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37429 PyObject *resultobj = 0;
37430 wxWindow *arg1 = (wxWindow *) 0 ;
37431 bool result;
37432 void *argp1 = 0 ;
37433 int res1 = 0 ;
37434 PyObject *swig_obj[1] ;
37435
37436 if (!args) SWIG_fail;
37437 swig_obj[0] = args;
37438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37439 if (!SWIG_IsOK(res1)) {
37440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37441 }
37442 arg1 = reinterpret_cast< wxWindow * >(argp1);
37443 {
37444 PyThreadState* __tstate = wxPyBeginAllowThreads();
37445 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37446 wxPyEndAllowThreads(__tstate);
37447 if (PyErr_Occurred()) SWIG_fail;
37448 }
37449 {
37450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37451 }
37452 return resultobj;
37453 fail:
37454 return NULL;
37455 }
37456
37457
37458 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37459 PyObject *resultobj = 0;
37460 wxWindow *arg1 = (wxWindow *) 0 ;
37461 bool result;
37462 void *argp1 = 0 ;
37463 int res1 = 0 ;
37464 PyObject *swig_obj[1] ;
37465
37466 if (!args) SWIG_fail;
37467 swig_obj[0] = args;
37468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37469 if (!SWIG_IsOK(res1)) {
37470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37471 }
37472 arg1 = reinterpret_cast< wxWindow * >(argp1);
37473 {
37474 PyThreadState* __tstate = wxPyBeginAllowThreads();
37475 result = (bool)(arg1)->Layout();
37476 wxPyEndAllowThreads(__tstate);
37477 if (PyErr_Occurred()) SWIG_fail;
37478 }
37479 {
37480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37481 }
37482 return resultobj;
37483 fail:
37484 return NULL;
37485 }
37486
37487
37488 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37489 PyObject *resultobj = 0;
37490 wxWindow *arg1 = (wxWindow *) 0 ;
37491 wxSizer *arg2 = (wxSizer *) 0 ;
37492 bool arg3 = (bool) true ;
37493 void *argp1 = 0 ;
37494 int res1 = 0 ;
37495 int res2 = 0 ;
37496 bool val3 ;
37497 int ecode3 = 0 ;
37498 PyObject * obj0 = 0 ;
37499 PyObject * obj1 = 0 ;
37500 PyObject * obj2 = 0 ;
37501 char * kwnames[] = {
37502 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37503 };
37504
37505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37507 if (!SWIG_IsOK(res1)) {
37508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37509 }
37510 arg1 = reinterpret_cast< wxWindow * >(argp1);
37511 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37512 if (!SWIG_IsOK(res2)) {
37513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37514 }
37515 if (obj2) {
37516 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37517 if (!SWIG_IsOK(ecode3)) {
37518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37519 }
37520 arg3 = static_cast< bool >(val3);
37521 }
37522 {
37523 PyThreadState* __tstate = wxPyBeginAllowThreads();
37524 (arg1)->SetSizer(arg2,arg3);
37525 wxPyEndAllowThreads(__tstate);
37526 if (PyErr_Occurred()) SWIG_fail;
37527 }
37528 resultobj = SWIG_Py_Void();
37529 return resultobj;
37530 fail:
37531 return NULL;
37532 }
37533
37534
37535 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37536 PyObject *resultobj = 0;
37537 wxWindow *arg1 = (wxWindow *) 0 ;
37538 wxSizer *arg2 = (wxSizer *) 0 ;
37539 bool arg3 = (bool) true ;
37540 void *argp1 = 0 ;
37541 int res1 = 0 ;
37542 int res2 = 0 ;
37543 bool val3 ;
37544 int ecode3 = 0 ;
37545 PyObject * obj0 = 0 ;
37546 PyObject * obj1 = 0 ;
37547 PyObject * obj2 = 0 ;
37548 char * kwnames[] = {
37549 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37550 };
37551
37552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37554 if (!SWIG_IsOK(res1)) {
37555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37556 }
37557 arg1 = reinterpret_cast< wxWindow * >(argp1);
37558 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37559 if (!SWIG_IsOK(res2)) {
37560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37561 }
37562 if (obj2) {
37563 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37564 if (!SWIG_IsOK(ecode3)) {
37565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37566 }
37567 arg3 = static_cast< bool >(val3);
37568 }
37569 {
37570 PyThreadState* __tstate = wxPyBeginAllowThreads();
37571 (arg1)->SetSizerAndFit(arg2,arg3);
37572 wxPyEndAllowThreads(__tstate);
37573 if (PyErr_Occurred()) SWIG_fail;
37574 }
37575 resultobj = SWIG_Py_Void();
37576 return resultobj;
37577 fail:
37578 return NULL;
37579 }
37580
37581
37582 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37583 PyObject *resultobj = 0;
37584 wxWindow *arg1 = (wxWindow *) 0 ;
37585 wxSizer *result = 0 ;
37586 void *argp1 = 0 ;
37587 int res1 = 0 ;
37588 PyObject *swig_obj[1] ;
37589
37590 if (!args) SWIG_fail;
37591 swig_obj[0] = args;
37592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37593 if (!SWIG_IsOK(res1)) {
37594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37595 }
37596 arg1 = reinterpret_cast< wxWindow * >(argp1);
37597 {
37598 PyThreadState* __tstate = wxPyBeginAllowThreads();
37599 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37600 wxPyEndAllowThreads(__tstate);
37601 if (PyErr_Occurred()) SWIG_fail;
37602 }
37603 {
37604 resultobj = wxPyMake_wxObject(result, (bool)0);
37605 }
37606 return resultobj;
37607 fail:
37608 return NULL;
37609 }
37610
37611
37612 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37613 PyObject *resultobj = 0;
37614 wxWindow *arg1 = (wxWindow *) 0 ;
37615 wxSizer *arg2 = (wxSizer *) 0 ;
37616 void *argp1 = 0 ;
37617 int res1 = 0 ;
37618 void *argp2 = 0 ;
37619 int res2 = 0 ;
37620 PyObject * obj0 = 0 ;
37621 PyObject * obj1 = 0 ;
37622 char * kwnames[] = {
37623 (char *) "self",(char *) "sizer", NULL
37624 };
37625
37626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37628 if (!SWIG_IsOK(res1)) {
37629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37630 }
37631 arg1 = reinterpret_cast< wxWindow * >(argp1);
37632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37633 if (!SWIG_IsOK(res2)) {
37634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37635 }
37636 arg2 = reinterpret_cast< wxSizer * >(argp2);
37637 {
37638 PyThreadState* __tstate = wxPyBeginAllowThreads();
37639 (arg1)->SetContainingSizer(arg2);
37640 wxPyEndAllowThreads(__tstate);
37641 if (PyErr_Occurred()) SWIG_fail;
37642 }
37643 resultobj = SWIG_Py_Void();
37644 return resultobj;
37645 fail:
37646 return NULL;
37647 }
37648
37649
37650 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37651 PyObject *resultobj = 0;
37652 wxWindow *arg1 = (wxWindow *) 0 ;
37653 wxSizer *result = 0 ;
37654 void *argp1 = 0 ;
37655 int res1 = 0 ;
37656 PyObject *swig_obj[1] ;
37657
37658 if (!args) SWIG_fail;
37659 swig_obj[0] = args;
37660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37661 if (!SWIG_IsOK(res1)) {
37662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37663 }
37664 arg1 = reinterpret_cast< wxWindow * >(argp1);
37665 {
37666 PyThreadState* __tstate = wxPyBeginAllowThreads();
37667 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37668 wxPyEndAllowThreads(__tstate);
37669 if (PyErr_Occurred()) SWIG_fail;
37670 }
37671 {
37672 resultobj = wxPyMake_wxObject(result, (bool)0);
37673 }
37674 return resultobj;
37675 fail:
37676 return NULL;
37677 }
37678
37679
37680 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37681 PyObject *resultobj = 0;
37682 wxWindow *arg1 = (wxWindow *) 0 ;
37683 void *argp1 = 0 ;
37684 int res1 = 0 ;
37685 PyObject *swig_obj[1] ;
37686
37687 if (!args) SWIG_fail;
37688 swig_obj[0] = args;
37689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37690 if (!SWIG_IsOK(res1)) {
37691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37692 }
37693 arg1 = reinterpret_cast< wxWindow * >(argp1);
37694 {
37695 PyThreadState* __tstate = wxPyBeginAllowThreads();
37696 (arg1)->InheritAttributes();
37697 wxPyEndAllowThreads(__tstate);
37698 if (PyErr_Occurred()) SWIG_fail;
37699 }
37700 resultobj = SWIG_Py_Void();
37701 return resultobj;
37702 fail:
37703 return NULL;
37704 }
37705
37706
37707 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37708 PyObject *resultobj = 0;
37709 wxWindow *arg1 = (wxWindow *) 0 ;
37710 bool result;
37711 void *argp1 = 0 ;
37712 int res1 = 0 ;
37713 PyObject *swig_obj[1] ;
37714
37715 if (!args) SWIG_fail;
37716 swig_obj[0] = args;
37717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37718 if (!SWIG_IsOK(res1)) {
37719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37720 }
37721 arg1 = reinterpret_cast< wxWindow * >(argp1);
37722 {
37723 PyThreadState* __tstate = wxPyBeginAllowThreads();
37724 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 {
37729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37730 }
37731 return resultobj;
37732 fail:
37733 return NULL;
37734 }
37735
37736
37737 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37738 PyObject *obj;
37739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37740 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37741 return SWIG_Py_Void();
37742 }
37743
37744 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37745 return SWIG_Python_InitShadowInstance(args);
37746 }
37747
37748 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37749 PyObject *resultobj = 0;
37750 long arg1 ;
37751 wxWindow *arg2 = (wxWindow *) NULL ;
37752 wxWindow *result = 0 ;
37753 long val1 ;
37754 int ecode1 = 0 ;
37755 void *argp2 = 0 ;
37756 int res2 = 0 ;
37757 PyObject * obj0 = 0 ;
37758 PyObject * obj1 = 0 ;
37759 char * kwnames[] = {
37760 (char *) "id",(char *) "parent", NULL
37761 };
37762
37763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37764 ecode1 = SWIG_AsVal_long(obj0, &val1);
37765 if (!SWIG_IsOK(ecode1)) {
37766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37767 }
37768 arg1 = static_cast< long >(val1);
37769 if (obj1) {
37770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37771 if (!SWIG_IsOK(res2)) {
37772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37773 }
37774 arg2 = reinterpret_cast< wxWindow * >(argp2);
37775 }
37776 {
37777 if (!wxPyCheckForApp()) SWIG_fail;
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37780 wxPyEndAllowThreads(__tstate);
37781 if (PyErr_Occurred()) SWIG_fail;
37782 }
37783 {
37784 resultobj = wxPyMake_wxObject(result, 0);
37785 }
37786 return resultobj;
37787 fail:
37788 return NULL;
37789 }
37790
37791
37792 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37793 PyObject *resultobj = 0;
37794 wxString *arg1 = 0 ;
37795 wxWindow *arg2 = (wxWindow *) NULL ;
37796 wxWindow *result = 0 ;
37797 bool temp1 = false ;
37798 void *argp2 = 0 ;
37799 int res2 = 0 ;
37800 PyObject * obj0 = 0 ;
37801 PyObject * obj1 = 0 ;
37802 char * kwnames[] = {
37803 (char *) "name",(char *) "parent", NULL
37804 };
37805
37806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37807 {
37808 arg1 = wxString_in_helper(obj0);
37809 if (arg1 == NULL) SWIG_fail;
37810 temp1 = true;
37811 }
37812 if (obj1) {
37813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37814 if (!SWIG_IsOK(res2)) {
37815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37816 }
37817 arg2 = reinterpret_cast< wxWindow * >(argp2);
37818 }
37819 {
37820 if (!wxPyCheckForApp()) SWIG_fail;
37821 PyThreadState* __tstate = wxPyBeginAllowThreads();
37822 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37823 wxPyEndAllowThreads(__tstate);
37824 if (PyErr_Occurred()) SWIG_fail;
37825 }
37826 {
37827 resultobj = wxPyMake_wxObject(result, 0);
37828 }
37829 {
37830 if (temp1)
37831 delete arg1;
37832 }
37833 return resultobj;
37834 fail:
37835 {
37836 if (temp1)
37837 delete arg1;
37838 }
37839 return NULL;
37840 }
37841
37842
37843 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37844 PyObject *resultobj = 0;
37845 wxString *arg1 = 0 ;
37846 wxWindow *arg2 = (wxWindow *) NULL ;
37847 wxWindow *result = 0 ;
37848 bool temp1 = false ;
37849 void *argp2 = 0 ;
37850 int res2 = 0 ;
37851 PyObject * obj0 = 0 ;
37852 PyObject * obj1 = 0 ;
37853 char * kwnames[] = {
37854 (char *) "label",(char *) "parent", NULL
37855 };
37856
37857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37858 {
37859 arg1 = wxString_in_helper(obj0);
37860 if (arg1 == NULL) SWIG_fail;
37861 temp1 = true;
37862 }
37863 if (obj1) {
37864 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37865 if (!SWIG_IsOK(res2)) {
37866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37867 }
37868 arg2 = reinterpret_cast< wxWindow * >(argp2);
37869 }
37870 {
37871 if (!wxPyCheckForApp()) SWIG_fail;
37872 PyThreadState* __tstate = wxPyBeginAllowThreads();
37873 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37874 wxPyEndAllowThreads(__tstate);
37875 if (PyErr_Occurred()) SWIG_fail;
37876 }
37877 {
37878 resultobj = wxPyMake_wxObject(result, 0);
37879 }
37880 {
37881 if (temp1)
37882 delete arg1;
37883 }
37884 return resultobj;
37885 fail:
37886 {
37887 if (temp1)
37888 delete arg1;
37889 }
37890 return NULL;
37891 }
37892
37893
37894 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37895 PyObject *resultobj = 0;
37896 wxWindow *arg1 = (wxWindow *) 0 ;
37897 unsigned long arg2 ;
37898 wxWindow *result = 0 ;
37899 void *argp1 = 0 ;
37900 int res1 = 0 ;
37901 unsigned long val2 ;
37902 int ecode2 = 0 ;
37903 PyObject * obj0 = 0 ;
37904 PyObject * obj1 = 0 ;
37905 char * kwnames[] = {
37906 (char *) "parent",(char *) "_hWnd", NULL
37907 };
37908
37909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37911 if (!SWIG_IsOK(res1)) {
37912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37913 }
37914 arg1 = reinterpret_cast< wxWindow * >(argp1);
37915 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37916 if (!SWIG_IsOK(ecode2)) {
37917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37918 }
37919 arg2 = static_cast< unsigned long >(val2);
37920 {
37921 PyThreadState* __tstate = wxPyBeginAllowThreads();
37922 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37923 wxPyEndAllowThreads(__tstate);
37924 if (PyErr_Occurred()) SWIG_fail;
37925 }
37926 {
37927 resultobj = wxPyMake_wxObject(result, 0);
37928 }
37929 return resultobj;
37930 fail:
37931 return NULL;
37932 }
37933
37934
37935 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37936 PyObject *resultobj = 0;
37937 PyObject *result = 0 ;
37938
37939 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37940 {
37941 PyThreadState* __tstate = wxPyBeginAllowThreads();
37942 result = (PyObject *)GetTopLevelWindows();
37943 wxPyEndAllowThreads(__tstate);
37944 if (PyErr_Occurred()) SWIG_fail;
37945 }
37946 resultobj = result;
37947 return resultobj;
37948 fail:
37949 return NULL;
37950 }
37951
37952
37953 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37954 PyObject *resultobj = 0;
37955 wxValidator *result = 0 ;
37956
37957 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37958 {
37959 PyThreadState* __tstate = wxPyBeginAllowThreads();
37960 result = (wxValidator *)new wxValidator();
37961 wxPyEndAllowThreads(__tstate);
37962 if (PyErr_Occurred()) SWIG_fail;
37963 }
37964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37965 return resultobj;
37966 fail:
37967 return NULL;
37968 }
37969
37970
37971 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37972 PyObject *resultobj = 0;
37973 wxValidator *arg1 = (wxValidator *) 0 ;
37974 wxValidator *result = 0 ;
37975 void *argp1 = 0 ;
37976 int res1 = 0 ;
37977 PyObject *swig_obj[1] ;
37978
37979 if (!args) SWIG_fail;
37980 swig_obj[0] = args;
37981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37982 if (!SWIG_IsOK(res1)) {
37983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37984 }
37985 arg1 = reinterpret_cast< wxValidator * >(argp1);
37986 {
37987 PyThreadState* __tstate = wxPyBeginAllowThreads();
37988 result = (wxValidator *)(arg1)->Clone();
37989 wxPyEndAllowThreads(__tstate);
37990 if (PyErr_Occurred()) SWIG_fail;
37991 }
37992 {
37993 resultobj = wxPyMake_wxObject(result, 0);
37994 }
37995 return resultobj;
37996 fail:
37997 return NULL;
37998 }
37999
38000
38001 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38002 PyObject *resultobj = 0;
38003 wxValidator *arg1 = (wxValidator *) 0 ;
38004 wxWindow *arg2 = (wxWindow *) 0 ;
38005 bool result;
38006 void *argp1 = 0 ;
38007 int res1 = 0 ;
38008 void *argp2 = 0 ;
38009 int res2 = 0 ;
38010 PyObject * obj0 = 0 ;
38011 PyObject * obj1 = 0 ;
38012 char * kwnames[] = {
38013 (char *) "self",(char *) "parent", NULL
38014 };
38015
38016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38018 if (!SWIG_IsOK(res1)) {
38019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38020 }
38021 arg1 = reinterpret_cast< wxValidator * >(argp1);
38022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38023 if (!SWIG_IsOK(res2)) {
38024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38025 }
38026 arg2 = reinterpret_cast< wxWindow * >(argp2);
38027 {
38028 PyThreadState* __tstate = wxPyBeginAllowThreads();
38029 result = (bool)(arg1)->Validate(arg2);
38030 wxPyEndAllowThreads(__tstate);
38031 if (PyErr_Occurred()) SWIG_fail;
38032 }
38033 {
38034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38035 }
38036 return resultobj;
38037 fail:
38038 return NULL;
38039 }
38040
38041
38042 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38043 PyObject *resultobj = 0;
38044 wxValidator *arg1 = (wxValidator *) 0 ;
38045 bool result;
38046 void *argp1 = 0 ;
38047 int res1 = 0 ;
38048 PyObject *swig_obj[1] ;
38049
38050 if (!args) SWIG_fail;
38051 swig_obj[0] = args;
38052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38053 if (!SWIG_IsOK(res1)) {
38054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38055 }
38056 arg1 = reinterpret_cast< wxValidator * >(argp1);
38057 {
38058 PyThreadState* __tstate = wxPyBeginAllowThreads();
38059 result = (bool)(arg1)->TransferToWindow();
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 {
38064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38065 }
38066 return resultobj;
38067 fail:
38068 return NULL;
38069 }
38070
38071
38072 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38073 PyObject *resultobj = 0;
38074 wxValidator *arg1 = (wxValidator *) 0 ;
38075 bool result;
38076 void *argp1 = 0 ;
38077 int res1 = 0 ;
38078 PyObject *swig_obj[1] ;
38079
38080 if (!args) SWIG_fail;
38081 swig_obj[0] = args;
38082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38083 if (!SWIG_IsOK(res1)) {
38084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38085 }
38086 arg1 = reinterpret_cast< wxValidator * >(argp1);
38087 {
38088 PyThreadState* __tstate = wxPyBeginAllowThreads();
38089 result = (bool)(arg1)->TransferFromWindow();
38090 wxPyEndAllowThreads(__tstate);
38091 if (PyErr_Occurred()) SWIG_fail;
38092 }
38093 {
38094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38095 }
38096 return resultobj;
38097 fail:
38098 return NULL;
38099 }
38100
38101
38102 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38103 PyObject *resultobj = 0;
38104 wxValidator *arg1 = (wxValidator *) 0 ;
38105 wxWindow *result = 0 ;
38106 void *argp1 = 0 ;
38107 int res1 = 0 ;
38108 PyObject *swig_obj[1] ;
38109
38110 if (!args) SWIG_fail;
38111 swig_obj[0] = args;
38112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38113 if (!SWIG_IsOK(res1)) {
38114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38115 }
38116 arg1 = reinterpret_cast< wxValidator * >(argp1);
38117 {
38118 PyThreadState* __tstate = wxPyBeginAllowThreads();
38119 result = (wxWindow *)(arg1)->GetWindow();
38120 wxPyEndAllowThreads(__tstate);
38121 if (PyErr_Occurred()) SWIG_fail;
38122 }
38123 {
38124 resultobj = wxPyMake_wxObject(result, 0);
38125 }
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38133 PyObject *resultobj = 0;
38134 wxValidator *arg1 = (wxValidator *) 0 ;
38135 wxWindow *arg2 = (wxWindow *) 0 ;
38136 void *argp1 = 0 ;
38137 int res1 = 0 ;
38138 void *argp2 = 0 ;
38139 int res2 = 0 ;
38140 PyObject * obj0 = 0 ;
38141 PyObject * obj1 = 0 ;
38142 char * kwnames[] = {
38143 (char *) "self",(char *) "window", NULL
38144 };
38145
38146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38148 if (!SWIG_IsOK(res1)) {
38149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38150 }
38151 arg1 = reinterpret_cast< wxValidator * >(argp1);
38152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38153 if (!SWIG_IsOK(res2)) {
38154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38155 }
38156 arg2 = reinterpret_cast< wxWindow * >(argp2);
38157 {
38158 PyThreadState* __tstate = wxPyBeginAllowThreads();
38159 (arg1)->SetWindow(arg2);
38160 wxPyEndAllowThreads(__tstate);
38161 if (PyErr_Occurred()) SWIG_fail;
38162 }
38163 resultobj = SWIG_Py_Void();
38164 return resultobj;
38165 fail:
38166 return NULL;
38167 }
38168
38169
38170 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38171 PyObject *resultobj = 0;
38172 bool result;
38173
38174 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38175 {
38176 PyThreadState* __tstate = wxPyBeginAllowThreads();
38177 result = (bool)wxValidator::IsSilent();
38178 wxPyEndAllowThreads(__tstate);
38179 if (PyErr_Occurred()) SWIG_fail;
38180 }
38181 {
38182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38183 }
38184 return resultobj;
38185 fail:
38186 return NULL;
38187 }
38188
38189
38190 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38191 PyObject *resultobj = 0;
38192 int arg1 = (int) true ;
38193 int val1 ;
38194 int ecode1 = 0 ;
38195 PyObject * obj0 = 0 ;
38196 char * kwnames[] = {
38197 (char *) "doIt", NULL
38198 };
38199
38200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38201 if (obj0) {
38202 ecode1 = SWIG_AsVal_int(obj0, &val1);
38203 if (!SWIG_IsOK(ecode1)) {
38204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38205 }
38206 arg1 = static_cast< int >(val1);
38207 }
38208 {
38209 PyThreadState* __tstate = wxPyBeginAllowThreads();
38210 wxValidator::SetBellOnError(arg1);
38211 wxPyEndAllowThreads(__tstate);
38212 if (PyErr_Occurred()) SWIG_fail;
38213 }
38214 resultobj = SWIG_Py_Void();
38215 return resultobj;
38216 fail:
38217 return NULL;
38218 }
38219
38220
38221 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38222 PyObject *obj;
38223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38224 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38225 return SWIG_Py_Void();
38226 }
38227
38228 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38229 return SWIG_Python_InitShadowInstance(args);
38230 }
38231
38232 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38233 PyObject *resultobj = 0;
38234 wxPyValidator *result = 0 ;
38235
38236 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38237 {
38238 PyThreadState* __tstate = wxPyBeginAllowThreads();
38239 result = (wxPyValidator *)new wxPyValidator();
38240 wxPyEndAllowThreads(__tstate);
38241 if (PyErr_Occurred()) SWIG_fail;
38242 }
38243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38244 return resultobj;
38245 fail:
38246 return NULL;
38247 }
38248
38249
38250 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38251 PyObject *resultobj = 0;
38252 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38253 PyObject *arg2 = (PyObject *) 0 ;
38254 PyObject *arg3 = (PyObject *) 0 ;
38255 int arg4 = (int) true ;
38256 void *argp1 = 0 ;
38257 int res1 = 0 ;
38258 int val4 ;
38259 int ecode4 = 0 ;
38260 PyObject * obj0 = 0 ;
38261 PyObject * obj1 = 0 ;
38262 PyObject * obj2 = 0 ;
38263 PyObject * obj3 = 0 ;
38264 char * kwnames[] = {
38265 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38266 };
38267
38268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38270 if (!SWIG_IsOK(res1)) {
38271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38272 }
38273 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38274 arg2 = obj1;
38275 arg3 = obj2;
38276 if (obj3) {
38277 ecode4 = SWIG_AsVal_int(obj3, &val4);
38278 if (!SWIG_IsOK(ecode4)) {
38279 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38280 }
38281 arg4 = static_cast< int >(val4);
38282 }
38283 {
38284 PyThreadState* __tstate = wxPyBeginAllowThreads();
38285 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38286 wxPyEndAllowThreads(__tstate);
38287 if (PyErr_Occurred()) SWIG_fail;
38288 }
38289 resultobj = SWIG_Py_Void();
38290 return resultobj;
38291 fail:
38292 return NULL;
38293 }
38294
38295
38296 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38297 PyObject *obj;
38298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38299 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38300 return SWIG_Py_Void();
38301 }
38302
38303 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38304 return SWIG_Python_InitShadowInstance(args);
38305 }
38306
38307 SWIGINTERN int DefaultValidator_set(PyObject *) {
38308 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38309 return 1;
38310 }
38311
38312
38313 SWIGINTERN PyObject *DefaultValidator_get(void) {
38314 PyObject *pyobj = 0;
38315
38316 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38317 return pyobj;
38318 }
38319
38320
38321 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38322 PyObject *resultobj = 0;
38323 wxString const &arg1_defvalue = wxPyEmptyString ;
38324 wxString *arg1 = (wxString *) &arg1_defvalue ;
38325 long arg2 = (long) 0 ;
38326 wxMenu *result = 0 ;
38327 bool temp1 = false ;
38328 long val2 ;
38329 int ecode2 = 0 ;
38330 PyObject * obj0 = 0 ;
38331 PyObject * obj1 = 0 ;
38332 char * kwnames[] = {
38333 (char *) "title",(char *) "style", NULL
38334 };
38335
38336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38337 if (obj0) {
38338 {
38339 arg1 = wxString_in_helper(obj0);
38340 if (arg1 == NULL) SWIG_fail;
38341 temp1 = true;
38342 }
38343 }
38344 if (obj1) {
38345 ecode2 = SWIG_AsVal_long(obj1, &val2);
38346 if (!SWIG_IsOK(ecode2)) {
38347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38348 }
38349 arg2 = static_cast< long >(val2);
38350 }
38351 {
38352 if (!wxPyCheckForApp()) SWIG_fail;
38353 PyThreadState* __tstate = wxPyBeginAllowThreads();
38354 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38355 wxPyEndAllowThreads(__tstate);
38356 if (PyErr_Occurred()) SWIG_fail;
38357 }
38358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38359 {
38360 if (temp1)
38361 delete arg1;
38362 }
38363 return resultobj;
38364 fail:
38365 {
38366 if (temp1)
38367 delete arg1;
38368 }
38369 return NULL;
38370 }
38371
38372
38373 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38374 PyObject *resultobj = 0;
38375 wxMenu *arg1 = (wxMenu *) 0 ;
38376 int arg2 ;
38377 wxString *arg3 = 0 ;
38378 wxString const &arg4_defvalue = wxPyEmptyString ;
38379 wxString *arg4 = (wxString *) &arg4_defvalue ;
38380 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38381 wxMenuItem *result = 0 ;
38382 void *argp1 = 0 ;
38383 int res1 = 0 ;
38384 int val2 ;
38385 int ecode2 = 0 ;
38386 bool temp3 = false ;
38387 bool temp4 = false ;
38388 int val5 ;
38389 int ecode5 = 0 ;
38390 PyObject * obj0 = 0 ;
38391 PyObject * obj1 = 0 ;
38392 PyObject * obj2 = 0 ;
38393 PyObject * obj3 = 0 ;
38394 PyObject * obj4 = 0 ;
38395 char * kwnames[] = {
38396 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38397 };
38398
38399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38401 if (!SWIG_IsOK(res1)) {
38402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38403 }
38404 arg1 = reinterpret_cast< wxMenu * >(argp1);
38405 ecode2 = SWIG_AsVal_int(obj1, &val2);
38406 if (!SWIG_IsOK(ecode2)) {
38407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38408 }
38409 arg2 = static_cast< int >(val2);
38410 {
38411 arg3 = wxString_in_helper(obj2);
38412 if (arg3 == NULL) SWIG_fail;
38413 temp3 = true;
38414 }
38415 if (obj3) {
38416 {
38417 arg4 = wxString_in_helper(obj3);
38418 if (arg4 == NULL) SWIG_fail;
38419 temp4 = true;
38420 }
38421 }
38422 if (obj4) {
38423 ecode5 = SWIG_AsVal_int(obj4, &val5);
38424 if (!SWIG_IsOK(ecode5)) {
38425 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38426 }
38427 arg5 = static_cast< wxItemKind >(val5);
38428 }
38429 {
38430 PyThreadState* __tstate = wxPyBeginAllowThreads();
38431 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38432 wxPyEndAllowThreads(__tstate);
38433 if (PyErr_Occurred()) SWIG_fail;
38434 }
38435 {
38436 resultobj = wxPyMake_wxObject(result, (bool)0);
38437 }
38438 {
38439 if (temp3)
38440 delete arg3;
38441 }
38442 {
38443 if (temp4)
38444 delete arg4;
38445 }
38446 return resultobj;
38447 fail:
38448 {
38449 if (temp3)
38450 delete arg3;
38451 }
38452 {
38453 if (temp4)
38454 delete arg4;
38455 }
38456 return NULL;
38457 }
38458
38459
38460 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38461 PyObject *resultobj = 0;
38462 wxMenu *arg1 = (wxMenu *) 0 ;
38463 wxMenuItem *result = 0 ;
38464 void *argp1 = 0 ;
38465 int res1 = 0 ;
38466 PyObject *swig_obj[1] ;
38467
38468 if (!args) SWIG_fail;
38469 swig_obj[0] = args;
38470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38471 if (!SWIG_IsOK(res1)) {
38472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38473 }
38474 arg1 = reinterpret_cast< wxMenu * >(argp1);
38475 {
38476 PyThreadState* __tstate = wxPyBeginAllowThreads();
38477 result = (wxMenuItem *)(arg1)->AppendSeparator();
38478 wxPyEndAllowThreads(__tstate);
38479 if (PyErr_Occurred()) SWIG_fail;
38480 }
38481 {
38482 resultobj = wxPyMake_wxObject(result, (bool)0);
38483 }
38484 return resultobj;
38485 fail:
38486 return NULL;
38487 }
38488
38489
38490 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38491 PyObject *resultobj = 0;
38492 wxMenu *arg1 = (wxMenu *) 0 ;
38493 int arg2 ;
38494 wxString *arg3 = 0 ;
38495 wxString const &arg4_defvalue = wxPyEmptyString ;
38496 wxString *arg4 = (wxString *) &arg4_defvalue ;
38497 wxMenuItem *result = 0 ;
38498 void *argp1 = 0 ;
38499 int res1 = 0 ;
38500 int val2 ;
38501 int ecode2 = 0 ;
38502 bool temp3 = false ;
38503 bool temp4 = false ;
38504 PyObject * obj0 = 0 ;
38505 PyObject * obj1 = 0 ;
38506 PyObject * obj2 = 0 ;
38507 PyObject * obj3 = 0 ;
38508 char * kwnames[] = {
38509 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38510 };
38511
38512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38514 if (!SWIG_IsOK(res1)) {
38515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38516 }
38517 arg1 = reinterpret_cast< wxMenu * >(argp1);
38518 ecode2 = SWIG_AsVal_int(obj1, &val2);
38519 if (!SWIG_IsOK(ecode2)) {
38520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38521 }
38522 arg2 = static_cast< int >(val2);
38523 {
38524 arg3 = wxString_in_helper(obj2);
38525 if (arg3 == NULL) SWIG_fail;
38526 temp3 = true;
38527 }
38528 if (obj3) {
38529 {
38530 arg4 = wxString_in_helper(obj3);
38531 if (arg4 == NULL) SWIG_fail;
38532 temp4 = true;
38533 }
38534 }
38535 {
38536 PyThreadState* __tstate = wxPyBeginAllowThreads();
38537 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38538 wxPyEndAllowThreads(__tstate);
38539 if (PyErr_Occurred()) SWIG_fail;
38540 }
38541 {
38542 resultobj = wxPyMake_wxObject(result, (bool)0);
38543 }
38544 {
38545 if (temp3)
38546 delete arg3;
38547 }
38548 {
38549 if (temp4)
38550 delete arg4;
38551 }
38552 return resultobj;
38553 fail:
38554 {
38555 if (temp3)
38556 delete arg3;
38557 }
38558 {
38559 if (temp4)
38560 delete arg4;
38561 }
38562 return NULL;
38563 }
38564
38565
38566 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38567 PyObject *resultobj = 0;
38568 wxMenu *arg1 = (wxMenu *) 0 ;
38569 int arg2 ;
38570 wxString *arg3 = 0 ;
38571 wxString const &arg4_defvalue = wxPyEmptyString ;
38572 wxString *arg4 = (wxString *) &arg4_defvalue ;
38573 wxMenuItem *result = 0 ;
38574 void *argp1 = 0 ;
38575 int res1 = 0 ;
38576 int val2 ;
38577 int ecode2 = 0 ;
38578 bool temp3 = false ;
38579 bool temp4 = false ;
38580 PyObject * obj0 = 0 ;
38581 PyObject * obj1 = 0 ;
38582 PyObject * obj2 = 0 ;
38583 PyObject * obj3 = 0 ;
38584 char * kwnames[] = {
38585 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38586 };
38587
38588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38590 if (!SWIG_IsOK(res1)) {
38591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38592 }
38593 arg1 = reinterpret_cast< wxMenu * >(argp1);
38594 ecode2 = SWIG_AsVal_int(obj1, &val2);
38595 if (!SWIG_IsOK(ecode2)) {
38596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38597 }
38598 arg2 = static_cast< int >(val2);
38599 {
38600 arg3 = wxString_in_helper(obj2);
38601 if (arg3 == NULL) SWIG_fail;
38602 temp3 = true;
38603 }
38604 if (obj3) {
38605 {
38606 arg4 = wxString_in_helper(obj3);
38607 if (arg4 == NULL) SWIG_fail;
38608 temp4 = true;
38609 }
38610 }
38611 {
38612 PyThreadState* __tstate = wxPyBeginAllowThreads();
38613 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38614 wxPyEndAllowThreads(__tstate);
38615 if (PyErr_Occurred()) SWIG_fail;
38616 }
38617 {
38618 resultobj = wxPyMake_wxObject(result, (bool)0);
38619 }
38620 {
38621 if (temp3)
38622 delete arg3;
38623 }
38624 {
38625 if (temp4)
38626 delete arg4;
38627 }
38628 return resultobj;
38629 fail:
38630 {
38631 if (temp3)
38632 delete arg3;
38633 }
38634 {
38635 if (temp4)
38636 delete arg4;
38637 }
38638 return NULL;
38639 }
38640
38641
38642 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38643 PyObject *resultobj = 0;
38644 wxMenu *arg1 = (wxMenu *) 0 ;
38645 int arg2 ;
38646 wxString *arg3 = 0 ;
38647 wxMenu *arg4 = (wxMenu *) 0 ;
38648 wxString const &arg5_defvalue = wxPyEmptyString ;
38649 wxString *arg5 = (wxString *) &arg5_defvalue ;
38650 wxMenuItem *result = 0 ;
38651 void *argp1 = 0 ;
38652 int res1 = 0 ;
38653 int val2 ;
38654 int ecode2 = 0 ;
38655 bool temp3 = false ;
38656 void *argp4 = 0 ;
38657 int res4 = 0 ;
38658 bool temp5 = false ;
38659 PyObject * obj0 = 0 ;
38660 PyObject * obj1 = 0 ;
38661 PyObject * obj2 = 0 ;
38662 PyObject * obj3 = 0 ;
38663 PyObject * obj4 = 0 ;
38664 char * kwnames[] = {
38665 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38666 };
38667
38668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38670 if (!SWIG_IsOK(res1)) {
38671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38672 }
38673 arg1 = reinterpret_cast< wxMenu * >(argp1);
38674 ecode2 = SWIG_AsVal_int(obj1, &val2);
38675 if (!SWIG_IsOK(ecode2)) {
38676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38677 }
38678 arg2 = static_cast< int >(val2);
38679 {
38680 arg3 = wxString_in_helper(obj2);
38681 if (arg3 == NULL) SWIG_fail;
38682 temp3 = true;
38683 }
38684 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38685 if (!SWIG_IsOK(res4)) {
38686 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38687 }
38688 arg4 = reinterpret_cast< wxMenu * >(argp4);
38689 if (obj4) {
38690 {
38691 arg5 = wxString_in_helper(obj4);
38692 if (arg5 == NULL) SWIG_fail;
38693 temp5 = true;
38694 }
38695 }
38696 {
38697 PyThreadState* __tstate = wxPyBeginAllowThreads();
38698 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38699 wxPyEndAllowThreads(__tstate);
38700 if (PyErr_Occurred()) SWIG_fail;
38701 }
38702 {
38703 resultobj = wxPyMake_wxObject(result, (bool)0);
38704 }
38705 {
38706 if (temp3)
38707 delete arg3;
38708 }
38709 {
38710 if (temp5)
38711 delete arg5;
38712 }
38713 return resultobj;
38714 fail:
38715 {
38716 if (temp3)
38717 delete arg3;
38718 }
38719 {
38720 if (temp5)
38721 delete arg5;
38722 }
38723 return NULL;
38724 }
38725
38726
38727 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38728 PyObject *resultobj = 0;
38729 wxMenu *arg1 = (wxMenu *) 0 ;
38730 wxMenu *arg2 = (wxMenu *) 0 ;
38731 wxString *arg3 = 0 ;
38732 wxString const &arg4_defvalue = wxPyEmptyString ;
38733 wxString *arg4 = (wxString *) &arg4_defvalue ;
38734 wxMenuItem *result = 0 ;
38735 void *argp1 = 0 ;
38736 int res1 = 0 ;
38737 void *argp2 = 0 ;
38738 int res2 = 0 ;
38739 bool temp3 = false ;
38740 bool temp4 = false ;
38741 PyObject * obj0 = 0 ;
38742 PyObject * obj1 = 0 ;
38743 PyObject * obj2 = 0 ;
38744 PyObject * obj3 = 0 ;
38745 char * kwnames[] = {
38746 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38747 };
38748
38749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38751 if (!SWIG_IsOK(res1)) {
38752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38753 }
38754 arg1 = reinterpret_cast< wxMenu * >(argp1);
38755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38756 if (!SWIG_IsOK(res2)) {
38757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38758 }
38759 arg2 = reinterpret_cast< wxMenu * >(argp2);
38760 {
38761 arg3 = wxString_in_helper(obj2);
38762 if (arg3 == NULL) SWIG_fail;
38763 temp3 = true;
38764 }
38765 if (obj3) {
38766 {
38767 arg4 = wxString_in_helper(obj3);
38768 if (arg4 == NULL) SWIG_fail;
38769 temp4 = true;
38770 }
38771 }
38772 {
38773 PyThreadState* __tstate = wxPyBeginAllowThreads();
38774 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38775 wxPyEndAllowThreads(__tstate);
38776 if (PyErr_Occurred()) SWIG_fail;
38777 }
38778 {
38779 resultobj = wxPyMake_wxObject(result, (bool)0);
38780 }
38781 {
38782 if (temp3)
38783 delete arg3;
38784 }
38785 {
38786 if (temp4)
38787 delete arg4;
38788 }
38789 return resultobj;
38790 fail:
38791 {
38792 if (temp3)
38793 delete arg3;
38794 }
38795 {
38796 if (temp4)
38797 delete arg4;
38798 }
38799 return NULL;
38800 }
38801
38802
38803 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38804 PyObject *resultobj = 0;
38805 wxMenu *arg1 = (wxMenu *) 0 ;
38806 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38807 wxMenuItem *result = 0 ;
38808 void *argp1 = 0 ;
38809 int res1 = 0 ;
38810 int res2 = 0 ;
38811 PyObject * obj0 = 0 ;
38812 PyObject * obj1 = 0 ;
38813 char * kwnames[] = {
38814 (char *) "self",(char *) "item", NULL
38815 };
38816
38817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38819 if (!SWIG_IsOK(res1)) {
38820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38821 }
38822 arg1 = reinterpret_cast< wxMenu * >(argp1);
38823 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38824 if (!SWIG_IsOK(res2)) {
38825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38826 }
38827 {
38828 PyThreadState* __tstate = wxPyBeginAllowThreads();
38829 result = (wxMenuItem *)(arg1)->Append(arg2);
38830 wxPyEndAllowThreads(__tstate);
38831 if (PyErr_Occurred()) SWIG_fail;
38832 }
38833 {
38834 resultobj = wxPyMake_wxObject(result, (bool)0);
38835 }
38836 return resultobj;
38837 fail:
38838 return NULL;
38839 }
38840
38841
38842 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38843 PyObject *resultobj = 0;
38844 wxMenu *arg1 = (wxMenu *) 0 ;
38845 size_t arg2 ;
38846 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38847 wxMenuItem *result = 0 ;
38848 void *argp1 = 0 ;
38849 int res1 = 0 ;
38850 size_t val2 ;
38851 int ecode2 = 0 ;
38852 int res3 = 0 ;
38853 PyObject * obj0 = 0 ;
38854 PyObject * obj1 = 0 ;
38855 PyObject * obj2 = 0 ;
38856 char * kwnames[] = {
38857 (char *) "self",(char *) "pos",(char *) "item", NULL
38858 };
38859
38860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38862 if (!SWIG_IsOK(res1)) {
38863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38864 }
38865 arg1 = reinterpret_cast< wxMenu * >(argp1);
38866 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38867 if (!SWIG_IsOK(ecode2)) {
38868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38869 }
38870 arg2 = static_cast< size_t >(val2);
38871 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38872 if (!SWIG_IsOK(res3)) {
38873 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38874 }
38875 {
38876 PyThreadState* __tstate = wxPyBeginAllowThreads();
38877 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38878 wxPyEndAllowThreads(__tstate);
38879 if (PyErr_Occurred()) SWIG_fail;
38880 }
38881 {
38882 resultobj = wxPyMake_wxObject(result, (bool)0);
38883 }
38884 return resultobj;
38885 fail:
38886 return NULL;
38887 }
38888
38889
38890 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38891 PyObject *resultobj = 0;
38892 wxMenu *arg1 = (wxMenu *) 0 ;
38893 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38894 wxMenuItem *result = 0 ;
38895 void *argp1 = 0 ;
38896 int res1 = 0 ;
38897 int res2 = 0 ;
38898 PyObject * obj0 = 0 ;
38899 PyObject * obj1 = 0 ;
38900 char * kwnames[] = {
38901 (char *) "self",(char *) "item", NULL
38902 };
38903
38904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38906 if (!SWIG_IsOK(res1)) {
38907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38908 }
38909 arg1 = reinterpret_cast< wxMenu * >(argp1);
38910 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38911 if (!SWIG_IsOK(res2)) {
38912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38913 }
38914 {
38915 PyThreadState* __tstate = wxPyBeginAllowThreads();
38916 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38917 wxPyEndAllowThreads(__tstate);
38918 if (PyErr_Occurred()) SWIG_fail;
38919 }
38920 {
38921 resultobj = wxPyMake_wxObject(result, (bool)0);
38922 }
38923 return resultobj;
38924 fail:
38925 return NULL;
38926 }
38927
38928
38929 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38930 PyObject *resultobj = 0;
38931 wxMenu *arg1 = (wxMenu *) 0 ;
38932 void *argp1 = 0 ;
38933 int res1 = 0 ;
38934 PyObject *swig_obj[1] ;
38935
38936 if (!args) SWIG_fail;
38937 swig_obj[0] = args;
38938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38939 if (!SWIG_IsOK(res1)) {
38940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38941 }
38942 arg1 = reinterpret_cast< wxMenu * >(argp1);
38943 {
38944 PyThreadState* __tstate = wxPyBeginAllowThreads();
38945 (arg1)->Break();
38946 wxPyEndAllowThreads(__tstate);
38947 if (PyErr_Occurred()) SWIG_fail;
38948 }
38949 resultobj = SWIG_Py_Void();
38950 return resultobj;
38951 fail:
38952 return NULL;
38953 }
38954
38955
38956 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38957 PyObject *resultobj = 0;
38958 wxMenu *arg1 = (wxMenu *) 0 ;
38959 size_t arg2 ;
38960 int arg3 ;
38961 wxString *arg4 = 0 ;
38962 wxString const &arg5_defvalue = wxPyEmptyString ;
38963 wxString *arg5 = (wxString *) &arg5_defvalue ;
38964 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38965 wxMenuItem *result = 0 ;
38966 void *argp1 = 0 ;
38967 int res1 = 0 ;
38968 size_t val2 ;
38969 int ecode2 = 0 ;
38970 int val3 ;
38971 int ecode3 = 0 ;
38972 bool temp4 = false ;
38973 bool temp5 = false ;
38974 int val6 ;
38975 int ecode6 = 0 ;
38976 PyObject * obj0 = 0 ;
38977 PyObject * obj1 = 0 ;
38978 PyObject * obj2 = 0 ;
38979 PyObject * obj3 = 0 ;
38980 PyObject * obj4 = 0 ;
38981 PyObject * obj5 = 0 ;
38982 char * kwnames[] = {
38983 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38984 };
38985
38986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38988 if (!SWIG_IsOK(res1)) {
38989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38990 }
38991 arg1 = reinterpret_cast< wxMenu * >(argp1);
38992 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38993 if (!SWIG_IsOK(ecode2)) {
38994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38995 }
38996 arg2 = static_cast< size_t >(val2);
38997 ecode3 = SWIG_AsVal_int(obj2, &val3);
38998 if (!SWIG_IsOK(ecode3)) {
38999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39000 }
39001 arg3 = static_cast< int >(val3);
39002 {
39003 arg4 = wxString_in_helper(obj3);
39004 if (arg4 == NULL) SWIG_fail;
39005 temp4 = true;
39006 }
39007 if (obj4) {
39008 {
39009 arg5 = wxString_in_helper(obj4);
39010 if (arg5 == NULL) SWIG_fail;
39011 temp5 = true;
39012 }
39013 }
39014 if (obj5) {
39015 ecode6 = SWIG_AsVal_int(obj5, &val6);
39016 if (!SWIG_IsOK(ecode6)) {
39017 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39018 }
39019 arg6 = static_cast< wxItemKind >(val6);
39020 }
39021 {
39022 PyThreadState* __tstate = wxPyBeginAllowThreads();
39023 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 {
39028 resultobj = wxPyMake_wxObject(result, (bool)0);
39029 }
39030 {
39031 if (temp4)
39032 delete arg4;
39033 }
39034 {
39035 if (temp5)
39036 delete arg5;
39037 }
39038 return resultobj;
39039 fail:
39040 {
39041 if (temp4)
39042 delete arg4;
39043 }
39044 {
39045 if (temp5)
39046 delete arg5;
39047 }
39048 return NULL;
39049 }
39050
39051
39052 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39053 PyObject *resultobj = 0;
39054 wxMenu *arg1 = (wxMenu *) 0 ;
39055 size_t arg2 ;
39056 wxMenuItem *result = 0 ;
39057 void *argp1 = 0 ;
39058 int res1 = 0 ;
39059 size_t val2 ;
39060 int ecode2 = 0 ;
39061 PyObject * obj0 = 0 ;
39062 PyObject * obj1 = 0 ;
39063 char * kwnames[] = {
39064 (char *) "self",(char *) "pos", NULL
39065 };
39066
39067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39069 if (!SWIG_IsOK(res1)) {
39070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39071 }
39072 arg1 = reinterpret_cast< wxMenu * >(argp1);
39073 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39074 if (!SWIG_IsOK(ecode2)) {
39075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39076 }
39077 arg2 = static_cast< size_t >(val2);
39078 {
39079 PyThreadState* __tstate = wxPyBeginAllowThreads();
39080 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39081 wxPyEndAllowThreads(__tstate);
39082 if (PyErr_Occurred()) SWIG_fail;
39083 }
39084 {
39085 resultobj = wxPyMake_wxObject(result, (bool)0);
39086 }
39087 return resultobj;
39088 fail:
39089 return NULL;
39090 }
39091
39092
39093 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39094 PyObject *resultobj = 0;
39095 wxMenu *arg1 = (wxMenu *) 0 ;
39096 size_t arg2 ;
39097 int arg3 ;
39098 wxString *arg4 = 0 ;
39099 wxString const &arg5_defvalue = wxPyEmptyString ;
39100 wxString *arg5 = (wxString *) &arg5_defvalue ;
39101 wxMenuItem *result = 0 ;
39102 void *argp1 = 0 ;
39103 int res1 = 0 ;
39104 size_t val2 ;
39105 int ecode2 = 0 ;
39106 int val3 ;
39107 int ecode3 = 0 ;
39108 bool temp4 = false ;
39109 bool temp5 = false ;
39110 PyObject * obj0 = 0 ;
39111 PyObject * obj1 = 0 ;
39112 PyObject * obj2 = 0 ;
39113 PyObject * obj3 = 0 ;
39114 PyObject * obj4 = 0 ;
39115 char * kwnames[] = {
39116 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39117 };
39118
39119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39121 if (!SWIG_IsOK(res1)) {
39122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39123 }
39124 arg1 = reinterpret_cast< wxMenu * >(argp1);
39125 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39126 if (!SWIG_IsOK(ecode2)) {
39127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39128 }
39129 arg2 = static_cast< size_t >(val2);
39130 ecode3 = SWIG_AsVal_int(obj2, &val3);
39131 if (!SWIG_IsOK(ecode3)) {
39132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39133 }
39134 arg3 = static_cast< int >(val3);
39135 {
39136 arg4 = wxString_in_helper(obj3);
39137 if (arg4 == NULL) SWIG_fail;
39138 temp4 = true;
39139 }
39140 if (obj4) {
39141 {
39142 arg5 = wxString_in_helper(obj4);
39143 if (arg5 == NULL) SWIG_fail;
39144 temp5 = true;
39145 }
39146 }
39147 {
39148 PyThreadState* __tstate = wxPyBeginAllowThreads();
39149 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39150 wxPyEndAllowThreads(__tstate);
39151 if (PyErr_Occurred()) SWIG_fail;
39152 }
39153 {
39154 resultobj = wxPyMake_wxObject(result, (bool)0);
39155 }
39156 {
39157 if (temp4)
39158 delete arg4;
39159 }
39160 {
39161 if (temp5)
39162 delete arg5;
39163 }
39164 return resultobj;
39165 fail:
39166 {
39167 if (temp4)
39168 delete arg4;
39169 }
39170 {
39171 if (temp5)
39172 delete arg5;
39173 }
39174 return NULL;
39175 }
39176
39177
39178 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39179 PyObject *resultobj = 0;
39180 wxMenu *arg1 = (wxMenu *) 0 ;
39181 size_t arg2 ;
39182 int arg3 ;
39183 wxString *arg4 = 0 ;
39184 wxString const &arg5_defvalue = wxPyEmptyString ;
39185 wxString *arg5 = (wxString *) &arg5_defvalue ;
39186 wxMenuItem *result = 0 ;
39187 void *argp1 = 0 ;
39188 int res1 = 0 ;
39189 size_t val2 ;
39190 int ecode2 = 0 ;
39191 int val3 ;
39192 int ecode3 = 0 ;
39193 bool temp4 = false ;
39194 bool temp5 = false ;
39195 PyObject * obj0 = 0 ;
39196 PyObject * obj1 = 0 ;
39197 PyObject * obj2 = 0 ;
39198 PyObject * obj3 = 0 ;
39199 PyObject * obj4 = 0 ;
39200 char * kwnames[] = {
39201 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39202 };
39203
39204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39206 if (!SWIG_IsOK(res1)) {
39207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39208 }
39209 arg1 = reinterpret_cast< wxMenu * >(argp1);
39210 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39211 if (!SWIG_IsOK(ecode2)) {
39212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39213 }
39214 arg2 = static_cast< size_t >(val2);
39215 ecode3 = SWIG_AsVal_int(obj2, &val3);
39216 if (!SWIG_IsOK(ecode3)) {
39217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39218 }
39219 arg3 = static_cast< int >(val3);
39220 {
39221 arg4 = wxString_in_helper(obj3);
39222 if (arg4 == NULL) SWIG_fail;
39223 temp4 = true;
39224 }
39225 if (obj4) {
39226 {
39227 arg5 = wxString_in_helper(obj4);
39228 if (arg5 == NULL) SWIG_fail;
39229 temp5 = true;
39230 }
39231 }
39232 {
39233 PyThreadState* __tstate = wxPyBeginAllowThreads();
39234 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39235 wxPyEndAllowThreads(__tstate);
39236 if (PyErr_Occurred()) SWIG_fail;
39237 }
39238 {
39239 resultobj = wxPyMake_wxObject(result, (bool)0);
39240 }
39241 {
39242 if (temp4)
39243 delete arg4;
39244 }
39245 {
39246 if (temp5)
39247 delete arg5;
39248 }
39249 return resultobj;
39250 fail:
39251 {
39252 if (temp4)
39253 delete arg4;
39254 }
39255 {
39256 if (temp5)
39257 delete arg5;
39258 }
39259 return NULL;
39260 }
39261
39262
39263 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39264 PyObject *resultobj = 0;
39265 wxMenu *arg1 = (wxMenu *) 0 ;
39266 size_t arg2 ;
39267 int arg3 ;
39268 wxString *arg4 = 0 ;
39269 wxMenu *arg5 = (wxMenu *) 0 ;
39270 wxString const &arg6_defvalue = wxPyEmptyString ;
39271 wxString *arg6 = (wxString *) &arg6_defvalue ;
39272 wxMenuItem *result = 0 ;
39273 void *argp1 = 0 ;
39274 int res1 = 0 ;
39275 size_t val2 ;
39276 int ecode2 = 0 ;
39277 int val3 ;
39278 int ecode3 = 0 ;
39279 bool temp4 = false ;
39280 void *argp5 = 0 ;
39281 int res5 = 0 ;
39282 bool temp6 = false ;
39283 PyObject * obj0 = 0 ;
39284 PyObject * obj1 = 0 ;
39285 PyObject * obj2 = 0 ;
39286 PyObject * obj3 = 0 ;
39287 PyObject * obj4 = 0 ;
39288 PyObject * obj5 = 0 ;
39289 char * kwnames[] = {
39290 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39291 };
39292
39293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39295 if (!SWIG_IsOK(res1)) {
39296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39297 }
39298 arg1 = reinterpret_cast< wxMenu * >(argp1);
39299 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39300 if (!SWIG_IsOK(ecode2)) {
39301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39302 }
39303 arg2 = static_cast< size_t >(val2);
39304 ecode3 = SWIG_AsVal_int(obj2, &val3);
39305 if (!SWIG_IsOK(ecode3)) {
39306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39307 }
39308 arg3 = static_cast< int >(val3);
39309 {
39310 arg4 = wxString_in_helper(obj3);
39311 if (arg4 == NULL) SWIG_fail;
39312 temp4 = true;
39313 }
39314 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39315 if (!SWIG_IsOK(res5)) {
39316 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39317 }
39318 arg5 = reinterpret_cast< wxMenu * >(argp5);
39319 if (obj5) {
39320 {
39321 arg6 = wxString_in_helper(obj5);
39322 if (arg6 == NULL) SWIG_fail;
39323 temp6 = true;
39324 }
39325 }
39326 {
39327 PyThreadState* __tstate = wxPyBeginAllowThreads();
39328 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39329 wxPyEndAllowThreads(__tstate);
39330 if (PyErr_Occurred()) SWIG_fail;
39331 }
39332 {
39333 resultobj = wxPyMake_wxObject(result, (bool)0);
39334 }
39335 {
39336 if (temp4)
39337 delete arg4;
39338 }
39339 {
39340 if (temp6)
39341 delete arg6;
39342 }
39343 return resultobj;
39344 fail:
39345 {
39346 if (temp4)
39347 delete arg4;
39348 }
39349 {
39350 if (temp6)
39351 delete arg6;
39352 }
39353 return NULL;
39354 }
39355
39356
39357 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39358 PyObject *resultobj = 0;
39359 wxMenu *arg1 = (wxMenu *) 0 ;
39360 int arg2 ;
39361 wxString *arg3 = 0 ;
39362 wxString const &arg4_defvalue = wxPyEmptyString ;
39363 wxString *arg4 = (wxString *) &arg4_defvalue ;
39364 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39365 wxMenuItem *result = 0 ;
39366 void *argp1 = 0 ;
39367 int res1 = 0 ;
39368 int val2 ;
39369 int ecode2 = 0 ;
39370 bool temp3 = false ;
39371 bool temp4 = false ;
39372 int val5 ;
39373 int ecode5 = 0 ;
39374 PyObject * obj0 = 0 ;
39375 PyObject * obj1 = 0 ;
39376 PyObject * obj2 = 0 ;
39377 PyObject * obj3 = 0 ;
39378 PyObject * obj4 = 0 ;
39379 char * kwnames[] = {
39380 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39381 };
39382
39383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39385 if (!SWIG_IsOK(res1)) {
39386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39387 }
39388 arg1 = reinterpret_cast< wxMenu * >(argp1);
39389 ecode2 = SWIG_AsVal_int(obj1, &val2);
39390 if (!SWIG_IsOK(ecode2)) {
39391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39392 }
39393 arg2 = static_cast< int >(val2);
39394 {
39395 arg3 = wxString_in_helper(obj2);
39396 if (arg3 == NULL) SWIG_fail;
39397 temp3 = true;
39398 }
39399 if (obj3) {
39400 {
39401 arg4 = wxString_in_helper(obj3);
39402 if (arg4 == NULL) SWIG_fail;
39403 temp4 = true;
39404 }
39405 }
39406 if (obj4) {
39407 ecode5 = SWIG_AsVal_int(obj4, &val5);
39408 if (!SWIG_IsOK(ecode5)) {
39409 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39410 }
39411 arg5 = static_cast< wxItemKind >(val5);
39412 }
39413 {
39414 PyThreadState* __tstate = wxPyBeginAllowThreads();
39415 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39416 wxPyEndAllowThreads(__tstate);
39417 if (PyErr_Occurred()) SWIG_fail;
39418 }
39419 {
39420 resultobj = wxPyMake_wxObject(result, (bool)0);
39421 }
39422 {
39423 if (temp3)
39424 delete arg3;
39425 }
39426 {
39427 if (temp4)
39428 delete arg4;
39429 }
39430 return resultobj;
39431 fail:
39432 {
39433 if (temp3)
39434 delete arg3;
39435 }
39436 {
39437 if (temp4)
39438 delete arg4;
39439 }
39440 return NULL;
39441 }
39442
39443
39444 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39445 PyObject *resultobj = 0;
39446 wxMenu *arg1 = (wxMenu *) 0 ;
39447 wxMenuItem *result = 0 ;
39448 void *argp1 = 0 ;
39449 int res1 = 0 ;
39450 PyObject *swig_obj[1] ;
39451
39452 if (!args) SWIG_fail;
39453 swig_obj[0] = args;
39454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39455 if (!SWIG_IsOK(res1)) {
39456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39457 }
39458 arg1 = reinterpret_cast< wxMenu * >(argp1);
39459 {
39460 PyThreadState* __tstate = wxPyBeginAllowThreads();
39461 result = (wxMenuItem *)(arg1)->PrependSeparator();
39462 wxPyEndAllowThreads(__tstate);
39463 if (PyErr_Occurred()) SWIG_fail;
39464 }
39465 {
39466 resultobj = wxPyMake_wxObject(result, (bool)0);
39467 }
39468 return resultobj;
39469 fail:
39470 return NULL;
39471 }
39472
39473
39474 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39475 PyObject *resultobj = 0;
39476 wxMenu *arg1 = (wxMenu *) 0 ;
39477 int arg2 ;
39478 wxString *arg3 = 0 ;
39479 wxString const &arg4_defvalue = wxPyEmptyString ;
39480 wxString *arg4 = (wxString *) &arg4_defvalue ;
39481 wxMenuItem *result = 0 ;
39482 void *argp1 = 0 ;
39483 int res1 = 0 ;
39484 int val2 ;
39485 int ecode2 = 0 ;
39486 bool temp3 = false ;
39487 bool temp4 = false ;
39488 PyObject * obj0 = 0 ;
39489 PyObject * obj1 = 0 ;
39490 PyObject * obj2 = 0 ;
39491 PyObject * obj3 = 0 ;
39492 char * kwnames[] = {
39493 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39494 };
39495
39496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39498 if (!SWIG_IsOK(res1)) {
39499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39500 }
39501 arg1 = reinterpret_cast< wxMenu * >(argp1);
39502 ecode2 = SWIG_AsVal_int(obj1, &val2);
39503 if (!SWIG_IsOK(ecode2)) {
39504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39505 }
39506 arg2 = static_cast< int >(val2);
39507 {
39508 arg3 = wxString_in_helper(obj2);
39509 if (arg3 == NULL) SWIG_fail;
39510 temp3 = true;
39511 }
39512 if (obj3) {
39513 {
39514 arg4 = wxString_in_helper(obj3);
39515 if (arg4 == NULL) SWIG_fail;
39516 temp4 = true;
39517 }
39518 }
39519 {
39520 PyThreadState* __tstate = wxPyBeginAllowThreads();
39521 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39522 wxPyEndAllowThreads(__tstate);
39523 if (PyErr_Occurred()) SWIG_fail;
39524 }
39525 {
39526 resultobj = wxPyMake_wxObject(result, (bool)0);
39527 }
39528 {
39529 if (temp3)
39530 delete arg3;
39531 }
39532 {
39533 if (temp4)
39534 delete arg4;
39535 }
39536 return resultobj;
39537 fail:
39538 {
39539 if (temp3)
39540 delete arg3;
39541 }
39542 {
39543 if (temp4)
39544 delete arg4;
39545 }
39546 return NULL;
39547 }
39548
39549
39550 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39551 PyObject *resultobj = 0;
39552 wxMenu *arg1 = (wxMenu *) 0 ;
39553 int arg2 ;
39554 wxString *arg3 = 0 ;
39555 wxString const &arg4_defvalue = wxPyEmptyString ;
39556 wxString *arg4 = (wxString *) &arg4_defvalue ;
39557 wxMenuItem *result = 0 ;
39558 void *argp1 = 0 ;
39559 int res1 = 0 ;
39560 int val2 ;
39561 int ecode2 = 0 ;
39562 bool temp3 = false ;
39563 bool temp4 = false ;
39564 PyObject * obj0 = 0 ;
39565 PyObject * obj1 = 0 ;
39566 PyObject * obj2 = 0 ;
39567 PyObject * obj3 = 0 ;
39568 char * kwnames[] = {
39569 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39570 };
39571
39572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39574 if (!SWIG_IsOK(res1)) {
39575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39576 }
39577 arg1 = reinterpret_cast< wxMenu * >(argp1);
39578 ecode2 = SWIG_AsVal_int(obj1, &val2);
39579 if (!SWIG_IsOK(ecode2)) {
39580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39581 }
39582 arg2 = static_cast< int >(val2);
39583 {
39584 arg3 = wxString_in_helper(obj2);
39585 if (arg3 == NULL) SWIG_fail;
39586 temp3 = true;
39587 }
39588 if (obj3) {
39589 {
39590 arg4 = wxString_in_helper(obj3);
39591 if (arg4 == NULL) SWIG_fail;
39592 temp4 = true;
39593 }
39594 }
39595 {
39596 PyThreadState* __tstate = wxPyBeginAllowThreads();
39597 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39598 wxPyEndAllowThreads(__tstate);
39599 if (PyErr_Occurred()) SWIG_fail;
39600 }
39601 {
39602 resultobj = wxPyMake_wxObject(result, (bool)0);
39603 }
39604 {
39605 if (temp3)
39606 delete arg3;
39607 }
39608 {
39609 if (temp4)
39610 delete arg4;
39611 }
39612 return resultobj;
39613 fail:
39614 {
39615 if (temp3)
39616 delete arg3;
39617 }
39618 {
39619 if (temp4)
39620 delete arg4;
39621 }
39622 return NULL;
39623 }
39624
39625
39626 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39627 PyObject *resultobj = 0;
39628 wxMenu *arg1 = (wxMenu *) 0 ;
39629 int arg2 ;
39630 wxString *arg3 = 0 ;
39631 wxMenu *arg4 = (wxMenu *) 0 ;
39632 wxString const &arg5_defvalue = wxPyEmptyString ;
39633 wxString *arg5 = (wxString *) &arg5_defvalue ;
39634 wxMenuItem *result = 0 ;
39635 void *argp1 = 0 ;
39636 int res1 = 0 ;
39637 int val2 ;
39638 int ecode2 = 0 ;
39639 bool temp3 = false ;
39640 void *argp4 = 0 ;
39641 int res4 = 0 ;
39642 bool temp5 = false ;
39643 PyObject * obj0 = 0 ;
39644 PyObject * obj1 = 0 ;
39645 PyObject * obj2 = 0 ;
39646 PyObject * obj3 = 0 ;
39647 PyObject * obj4 = 0 ;
39648 char * kwnames[] = {
39649 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39650 };
39651
39652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39654 if (!SWIG_IsOK(res1)) {
39655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39656 }
39657 arg1 = reinterpret_cast< wxMenu * >(argp1);
39658 ecode2 = SWIG_AsVal_int(obj1, &val2);
39659 if (!SWIG_IsOK(ecode2)) {
39660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39661 }
39662 arg2 = static_cast< int >(val2);
39663 {
39664 arg3 = wxString_in_helper(obj2);
39665 if (arg3 == NULL) SWIG_fail;
39666 temp3 = true;
39667 }
39668 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39669 if (!SWIG_IsOK(res4)) {
39670 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39671 }
39672 arg4 = reinterpret_cast< wxMenu * >(argp4);
39673 if (obj4) {
39674 {
39675 arg5 = wxString_in_helper(obj4);
39676 if (arg5 == NULL) SWIG_fail;
39677 temp5 = true;
39678 }
39679 }
39680 {
39681 PyThreadState* __tstate = wxPyBeginAllowThreads();
39682 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39683 wxPyEndAllowThreads(__tstate);
39684 if (PyErr_Occurred()) SWIG_fail;
39685 }
39686 {
39687 resultobj = wxPyMake_wxObject(result, (bool)0);
39688 }
39689 {
39690 if (temp3)
39691 delete arg3;
39692 }
39693 {
39694 if (temp5)
39695 delete arg5;
39696 }
39697 return resultobj;
39698 fail:
39699 {
39700 if (temp3)
39701 delete arg3;
39702 }
39703 {
39704 if (temp5)
39705 delete arg5;
39706 }
39707 return NULL;
39708 }
39709
39710
39711 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39712 PyObject *resultobj = 0;
39713 wxMenu *arg1 = (wxMenu *) 0 ;
39714 int arg2 ;
39715 wxMenuItem *result = 0 ;
39716 void *argp1 = 0 ;
39717 int res1 = 0 ;
39718 int val2 ;
39719 int ecode2 = 0 ;
39720 PyObject * obj0 = 0 ;
39721 PyObject * obj1 = 0 ;
39722 char * kwnames[] = {
39723 (char *) "self",(char *) "id", NULL
39724 };
39725
39726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39728 if (!SWIG_IsOK(res1)) {
39729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39730 }
39731 arg1 = reinterpret_cast< wxMenu * >(argp1);
39732 ecode2 = SWIG_AsVal_int(obj1, &val2);
39733 if (!SWIG_IsOK(ecode2)) {
39734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39735 }
39736 arg2 = static_cast< int >(val2);
39737 {
39738 PyThreadState* __tstate = wxPyBeginAllowThreads();
39739 result = (wxMenuItem *)(arg1)->Remove(arg2);
39740 wxPyEndAllowThreads(__tstate);
39741 if (PyErr_Occurred()) SWIG_fail;
39742 }
39743 {
39744 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39745 }
39746 return resultobj;
39747 fail:
39748 return NULL;
39749 }
39750
39751
39752 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39753 PyObject *resultobj = 0;
39754 wxMenu *arg1 = (wxMenu *) 0 ;
39755 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39756 wxMenuItem *result = 0 ;
39757 void *argp1 = 0 ;
39758 int res1 = 0 ;
39759 void *argp2 = 0 ;
39760 int res2 = 0 ;
39761 PyObject * obj0 = 0 ;
39762 PyObject * obj1 = 0 ;
39763 char * kwnames[] = {
39764 (char *) "self",(char *) "item", NULL
39765 };
39766
39767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39769 if (!SWIG_IsOK(res1)) {
39770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39771 }
39772 arg1 = reinterpret_cast< wxMenu * >(argp1);
39773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39774 if (!SWIG_IsOK(res2)) {
39775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39776 }
39777 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39778 {
39779 PyThreadState* __tstate = wxPyBeginAllowThreads();
39780 result = (wxMenuItem *)(arg1)->Remove(arg2);
39781 wxPyEndAllowThreads(__tstate);
39782 if (PyErr_Occurred()) SWIG_fail;
39783 }
39784 {
39785 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39786 }
39787 return resultobj;
39788 fail:
39789 return NULL;
39790 }
39791
39792
39793 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39794 PyObject *resultobj = 0;
39795 wxMenu *arg1 = (wxMenu *) 0 ;
39796 int arg2 ;
39797 bool result;
39798 void *argp1 = 0 ;
39799 int res1 = 0 ;
39800 int val2 ;
39801 int ecode2 = 0 ;
39802 PyObject * obj0 = 0 ;
39803 PyObject * obj1 = 0 ;
39804 char * kwnames[] = {
39805 (char *) "self",(char *) "id", NULL
39806 };
39807
39808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39810 if (!SWIG_IsOK(res1)) {
39811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39812 }
39813 arg1 = reinterpret_cast< wxMenu * >(argp1);
39814 ecode2 = SWIG_AsVal_int(obj1, &val2);
39815 if (!SWIG_IsOK(ecode2)) {
39816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39817 }
39818 arg2 = static_cast< int >(val2);
39819 {
39820 PyThreadState* __tstate = wxPyBeginAllowThreads();
39821 result = (bool)(arg1)->Delete(arg2);
39822 wxPyEndAllowThreads(__tstate);
39823 if (PyErr_Occurred()) SWIG_fail;
39824 }
39825 {
39826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39827 }
39828 return resultobj;
39829 fail:
39830 return NULL;
39831 }
39832
39833
39834 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39835 PyObject *resultobj = 0;
39836 wxMenu *arg1 = (wxMenu *) 0 ;
39837 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39838 bool result;
39839 void *argp1 = 0 ;
39840 int res1 = 0 ;
39841 void *argp2 = 0 ;
39842 int res2 = 0 ;
39843 PyObject * obj0 = 0 ;
39844 PyObject * obj1 = 0 ;
39845 char * kwnames[] = {
39846 (char *) "self",(char *) "item", NULL
39847 };
39848
39849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39851 if (!SWIG_IsOK(res1)) {
39852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39853 }
39854 arg1 = reinterpret_cast< wxMenu * >(argp1);
39855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39856 if (!SWIG_IsOK(res2)) {
39857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39858 }
39859 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39860 {
39861 PyThreadState* __tstate = wxPyBeginAllowThreads();
39862 result = (bool)(arg1)->Delete(arg2);
39863 wxPyEndAllowThreads(__tstate);
39864 if (PyErr_Occurred()) SWIG_fail;
39865 }
39866 {
39867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39868 }
39869 return resultobj;
39870 fail:
39871 return NULL;
39872 }
39873
39874
39875 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39876 PyObject *resultobj = 0;
39877 wxMenu *arg1 = (wxMenu *) 0 ;
39878 void *argp1 = 0 ;
39879 int res1 = 0 ;
39880 PyObject *swig_obj[1] ;
39881
39882 if (!args) SWIG_fail;
39883 swig_obj[0] = args;
39884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39885 if (!SWIG_IsOK(res1)) {
39886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39887 }
39888 arg1 = reinterpret_cast< wxMenu * >(argp1);
39889 {
39890 PyThreadState* __tstate = wxPyBeginAllowThreads();
39891 wxMenu_Destroy(arg1);
39892 wxPyEndAllowThreads(__tstate);
39893 if (PyErr_Occurred()) SWIG_fail;
39894 }
39895 resultobj = SWIG_Py_Void();
39896 return resultobj;
39897 fail:
39898 return NULL;
39899 }
39900
39901
39902 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39903 PyObject *resultobj = 0;
39904 wxMenu *arg1 = (wxMenu *) 0 ;
39905 int arg2 ;
39906 bool result;
39907 void *argp1 = 0 ;
39908 int res1 = 0 ;
39909 int val2 ;
39910 int ecode2 = 0 ;
39911 PyObject * obj0 = 0 ;
39912 PyObject * obj1 = 0 ;
39913 char * kwnames[] = {
39914 (char *) "self",(char *) "id", NULL
39915 };
39916
39917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39919 if (!SWIG_IsOK(res1)) {
39920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39921 }
39922 arg1 = reinterpret_cast< wxMenu * >(argp1);
39923 ecode2 = SWIG_AsVal_int(obj1, &val2);
39924 if (!SWIG_IsOK(ecode2)) {
39925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39926 }
39927 arg2 = static_cast< int >(val2);
39928 {
39929 PyThreadState* __tstate = wxPyBeginAllowThreads();
39930 result = (bool)(arg1)->Destroy(arg2);
39931 wxPyEndAllowThreads(__tstate);
39932 if (PyErr_Occurred()) SWIG_fail;
39933 }
39934 {
39935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39936 }
39937 return resultobj;
39938 fail:
39939 return NULL;
39940 }
39941
39942
39943 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39944 PyObject *resultobj = 0;
39945 wxMenu *arg1 = (wxMenu *) 0 ;
39946 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39947 bool result;
39948 void *argp1 = 0 ;
39949 int res1 = 0 ;
39950 void *argp2 = 0 ;
39951 int res2 = 0 ;
39952 PyObject * obj0 = 0 ;
39953 PyObject * obj1 = 0 ;
39954 char * kwnames[] = {
39955 (char *) "self",(char *) "item", NULL
39956 };
39957
39958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39960 if (!SWIG_IsOK(res1)) {
39961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39962 }
39963 arg1 = reinterpret_cast< wxMenu * >(argp1);
39964 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39965 if (!SWIG_IsOK(res2)) {
39966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39967 }
39968 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39969 {
39970 PyThreadState* __tstate = wxPyBeginAllowThreads();
39971 result = (bool)(arg1)->Destroy(arg2);
39972 wxPyEndAllowThreads(__tstate);
39973 if (PyErr_Occurred()) SWIG_fail;
39974 }
39975 {
39976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39977 }
39978 return resultobj;
39979 fail:
39980 return NULL;
39981 }
39982
39983
39984 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39985 PyObject *resultobj = 0;
39986 wxMenu *arg1 = (wxMenu *) 0 ;
39987 size_t result;
39988 void *argp1 = 0 ;
39989 int res1 = 0 ;
39990 PyObject *swig_obj[1] ;
39991
39992 if (!args) SWIG_fail;
39993 swig_obj[0] = args;
39994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39995 if (!SWIG_IsOK(res1)) {
39996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39997 }
39998 arg1 = reinterpret_cast< wxMenu * >(argp1);
39999 {
40000 PyThreadState* __tstate = wxPyBeginAllowThreads();
40001 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40002 wxPyEndAllowThreads(__tstate);
40003 if (PyErr_Occurred()) SWIG_fail;
40004 }
40005 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40013 PyObject *resultobj = 0;
40014 wxMenu *arg1 = (wxMenu *) 0 ;
40015 PyObject *result = 0 ;
40016 void *argp1 = 0 ;
40017 int res1 = 0 ;
40018 PyObject *swig_obj[1] ;
40019
40020 if (!args) SWIG_fail;
40021 swig_obj[0] = args;
40022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40023 if (!SWIG_IsOK(res1)) {
40024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40025 }
40026 arg1 = reinterpret_cast< wxMenu * >(argp1);
40027 {
40028 PyThreadState* __tstate = wxPyBeginAllowThreads();
40029 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40030 wxPyEndAllowThreads(__tstate);
40031 if (PyErr_Occurred()) SWIG_fail;
40032 }
40033 resultobj = result;
40034 return resultobj;
40035 fail:
40036 return NULL;
40037 }
40038
40039
40040 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40041 PyObject *resultobj = 0;
40042 wxMenu *arg1 = (wxMenu *) 0 ;
40043 wxString *arg2 = 0 ;
40044 int result;
40045 void *argp1 = 0 ;
40046 int res1 = 0 ;
40047 bool temp2 = false ;
40048 PyObject * obj0 = 0 ;
40049 PyObject * obj1 = 0 ;
40050 char * kwnames[] = {
40051 (char *) "self",(char *) "item", NULL
40052 };
40053
40054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40056 if (!SWIG_IsOK(res1)) {
40057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40058 }
40059 arg1 = reinterpret_cast< wxMenu * >(argp1);
40060 {
40061 arg2 = wxString_in_helper(obj1);
40062 if (arg2 == NULL) SWIG_fail;
40063 temp2 = true;
40064 }
40065 {
40066 PyThreadState* __tstate = wxPyBeginAllowThreads();
40067 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40068 wxPyEndAllowThreads(__tstate);
40069 if (PyErr_Occurred()) SWIG_fail;
40070 }
40071 resultobj = SWIG_From_int(static_cast< int >(result));
40072 {
40073 if (temp2)
40074 delete arg2;
40075 }
40076 return resultobj;
40077 fail:
40078 {
40079 if (temp2)
40080 delete arg2;
40081 }
40082 return NULL;
40083 }
40084
40085
40086 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40087 PyObject *resultobj = 0;
40088 wxMenu *arg1 = (wxMenu *) 0 ;
40089 int arg2 ;
40090 wxMenuItem *result = 0 ;
40091 void *argp1 = 0 ;
40092 int res1 = 0 ;
40093 int val2 ;
40094 int ecode2 = 0 ;
40095 PyObject * obj0 = 0 ;
40096 PyObject * obj1 = 0 ;
40097 char * kwnames[] = {
40098 (char *) "self",(char *) "id", NULL
40099 };
40100
40101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40103 if (!SWIG_IsOK(res1)) {
40104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40105 }
40106 arg1 = reinterpret_cast< wxMenu * >(argp1);
40107 ecode2 = SWIG_AsVal_int(obj1, &val2);
40108 if (!SWIG_IsOK(ecode2)) {
40109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40110 }
40111 arg2 = static_cast< int >(val2);
40112 {
40113 PyThreadState* __tstate = wxPyBeginAllowThreads();
40114 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40115 wxPyEndAllowThreads(__tstate);
40116 if (PyErr_Occurred()) SWIG_fail;
40117 }
40118 {
40119 resultobj = wxPyMake_wxObject(result, (bool)0);
40120 }
40121 return resultobj;
40122 fail:
40123 return NULL;
40124 }
40125
40126
40127 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40128 PyObject *resultobj = 0;
40129 wxMenu *arg1 = (wxMenu *) 0 ;
40130 size_t arg2 ;
40131 wxMenuItem *result = 0 ;
40132 void *argp1 = 0 ;
40133 int res1 = 0 ;
40134 size_t val2 ;
40135 int ecode2 = 0 ;
40136 PyObject * obj0 = 0 ;
40137 PyObject * obj1 = 0 ;
40138 char * kwnames[] = {
40139 (char *) "self",(char *) "position", NULL
40140 };
40141
40142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40144 if (!SWIG_IsOK(res1)) {
40145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40146 }
40147 arg1 = reinterpret_cast< wxMenu * >(argp1);
40148 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40149 if (!SWIG_IsOK(ecode2)) {
40150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40151 }
40152 arg2 = static_cast< size_t >(val2);
40153 {
40154 PyThreadState* __tstate = wxPyBeginAllowThreads();
40155 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40156 wxPyEndAllowThreads(__tstate);
40157 if (PyErr_Occurred()) SWIG_fail;
40158 }
40159 {
40160 resultobj = wxPyMake_wxObject(result, (bool)0);
40161 }
40162 return resultobj;
40163 fail:
40164 return NULL;
40165 }
40166
40167
40168 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40169 PyObject *resultobj = 0;
40170 wxMenu *arg1 = (wxMenu *) 0 ;
40171 int arg2 ;
40172 bool arg3 ;
40173 void *argp1 = 0 ;
40174 int res1 = 0 ;
40175 int val2 ;
40176 int ecode2 = 0 ;
40177 bool val3 ;
40178 int ecode3 = 0 ;
40179 PyObject * obj0 = 0 ;
40180 PyObject * obj1 = 0 ;
40181 PyObject * obj2 = 0 ;
40182 char * kwnames[] = {
40183 (char *) "self",(char *) "id",(char *) "enable", NULL
40184 };
40185
40186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40190 }
40191 arg1 = reinterpret_cast< wxMenu * >(argp1);
40192 ecode2 = SWIG_AsVal_int(obj1, &val2);
40193 if (!SWIG_IsOK(ecode2)) {
40194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40195 }
40196 arg2 = static_cast< int >(val2);
40197 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40198 if (!SWIG_IsOK(ecode3)) {
40199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40200 }
40201 arg3 = static_cast< bool >(val3);
40202 {
40203 PyThreadState* __tstate = wxPyBeginAllowThreads();
40204 (arg1)->Enable(arg2,arg3);
40205 wxPyEndAllowThreads(__tstate);
40206 if (PyErr_Occurred()) SWIG_fail;
40207 }
40208 resultobj = SWIG_Py_Void();
40209 return resultobj;
40210 fail:
40211 return NULL;
40212 }
40213
40214
40215 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40216 PyObject *resultobj = 0;
40217 wxMenu *arg1 = (wxMenu *) 0 ;
40218 int arg2 ;
40219 bool result;
40220 void *argp1 = 0 ;
40221 int res1 = 0 ;
40222 int val2 ;
40223 int ecode2 = 0 ;
40224 PyObject * obj0 = 0 ;
40225 PyObject * obj1 = 0 ;
40226 char * kwnames[] = {
40227 (char *) "self",(char *) "id", NULL
40228 };
40229
40230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40232 if (!SWIG_IsOK(res1)) {
40233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40234 }
40235 arg1 = reinterpret_cast< wxMenu * >(argp1);
40236 ecode2 = SWIG_AsVal_int(obj1, &val2);
40237 if (!SWIG_IsOK(ecode2)) {
40238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40239 }
40240 arg2 = static_cast< int >(val2);
40241 {
40242 PyThreadState* __tstate = wxPyBeginAllowThreads();
40243 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40244 wxPyEndAllowThreads(__tstate);
40245 if (PyErr_Occurred()) SWIG_fail;
40246 }
40247 {
40248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40249 }
40250 return resultobj;
40251 fail:
40252 return NULL;
40253 }
40254
40255
40256 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40257 PyObject *resultobj = 0;
40258 wxMenu *arg1 = (wxMenu *) 0 ;
40259 int arg2 ;
40260 bool arg3 ;
40261 void *argp1 = 0 ;
40262 int res1 = 0 ;
40263 int val2 ;
40264 int ecode2 = 0 ;
40265 bool val3 ;
40266 int ecode3 = 0 ;
40267 PyObject * obj0 = 0 ;
40268 PyObject * obj1 = 0 ;
40269 PyObject * obj2 = 0 ;
40270 char * kwnames[] = {
40271 (char *) "self",(char *) "id",(char *) "check", NULL
40272 };
40273
40274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40276 if (!SWIG_IsOK(res1)) {
40277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40278 }
40279 arg1 = reinterpret_cast< wxMenu * >(argp1);
40280 ecode2 = SWIG_AsVal_int(obj1, &val2);
40281 if (!SWIG_IsOK(ecode2)) {
40282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40283 }
40284 arg2 = static_cast< int >(val2);
40285 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40286 if (!SWIG_IsOK(ecode3)) {
40287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40288 }
40289 arg3 = static_cast< bool >(val3);
40290 {
40291 PyThreadState* __tstate = wxPyBeginAllowThreads();
40292 (arg1)->Check(arg2,arg3);
40293 wxPyEndAllowThreads(__tstate);
40294 if (PyErr_Occurred()) SWIG_fail;
40295 }
40296 resultobj = SWIG_Py_Void();
40297 return resultobj;
40298 fail:
40299 return NULL;
40300 }
40301
40302
40303 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40304 PyObject *resultobj = 0;
40305 wxMenu *arg1 = (wxMenu *) 0 ;
40306 int arg2 ;
40307 bool result;
40308 void *argp1 = 0 ;
40309 int res1 = 0 ;
40310 int val2 ;
40311 int ecode2 = 0 ;
40312 PyObject * obj0 = 0 ;
40313 PyObject * obj1 = 0 ;
40314 char * kwnames[] = {
40315 (char *) "self",(char *) "id", NULL
40316 };
40317
40318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40320 if (!SWIG_IsOK(res1)) {
40321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40322 }
40323 arg1 = reinterpret_cast< wxMenu * >(argp1);
40324 ecode2 = SWIG_AsVal_int(obj1, &val2);
40325 if (!SWIG_IsOK(ecode2)) {
40326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40327 }
40328 arg2 = static_cast< int >(val2);
40329 {
40330 PyThreadState* __tstate = wxPyBeginAllowThreads();
40331 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40332 wxPyEndAllowThreads(__tstate);
40333 if (PyErr_Occurred()) SWIG_fail;
40334 }
40335 {
40336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40337 }
40338 return resultobj;
40339 fail:
40340 return NULL;
40341 }
40342
40343
40344 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40345 PyObject *resultobj = 0;
40346 wxMenu *arg1 = (wxMenu *) 0 ;
40347 int arg2 ;
40348 wxString *arg3 = 0 ;
40349 void *argp1 = 0 ;
40350 int res1 = 0 ;
40351 int val2 ;
40352 int ecode2 = 0 ;
40353 bool temp3 = false ;
40354 PyObject * obj0 = 0 ;
40355 PyObject * obj1 = 0 ;
40356 PyObject * obj2 = 0 ;
40357 char * kwnames[] = {
40358 (char *) "self",(char *) "id",(char *) "label", NULL
40359 };
40360
40361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40363 if (!SWIG_IsOK(res1)) {
40364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40365 }
40366 arg1 = reinterpret_cast< wxMenu * >(argp1);
40367 ecode2 = SWIG_AsVal_int(obj1, &val2);
40368 if (!SWIG_IsOK(ecode2)) {
40369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40370 }
40371 arg2 = static_cast< int >(val2);
40372 {
40373 arg3 = wxString_in_helper(obj2);
40374 if (arg3 == NULL) SWIG_fail;
40375 temp3 = true;
40376 }
40377 {
40378 PyThreadState* __tstate = wxPyBeginAllowThreads();
40379 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40380 wxPyEndAllowThreads(__tstate);
40381 if (PyErr_Occurred()) SWIG_fail;
40382 }
40383 resultobj = SWIG_Py_Void();
40384 {
40385 if (temp3)
40386 delete arg3;
40387 }
40388 return resultobj;
40389 fail:
40390 {
40391 if (temp3)
40392 delete arg3;
40393 }
40394 return NULL;
40395 }
40396
40397
40398 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40399 PyObject *resultobj = 0;
40400 wxMenu *arg1 = (wxMenu *) 0 ;
40401 int arg2 ;
40402 wxString result;
40403 void *argp1 = 0 ;
40404 int res1 = 0 ;
40405 int val2 ;
40406 int ecode2 = 0 ;
40407 PyObject * obj0 = 0 ;
40408 PyObject * obj1 = 0 ;
40409 char * kwnames[] = {
40410 (char *) "self",(char *) "id", NULL
40411 };
40412
40413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40415 if (!SWIG_IsOK(res1)) {
40416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40417 }
40418 arg1 = reinterpret_cast< wxMenu * >(argp1);
40419 ecode2 = SWIG_AsVal_int(obj1, &val2);
40420 if (!SWIG_IsOK(ecode2)) {
40421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40422 }
40423 arg2 = static_cast< int >(val2);
40424 {
40425 PyThreadState* __tstate = wxPyBeginAllowThreads();
40426 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40427 wxPyEndAllowThreads(__tstate);
40428 if (PyErr_Occurred()) SWIG_fail;
40429 }
40430 {
40431 #if wxUSE_UNICODE
40432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40433 #else
40434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40435 #endif
40436 }
40437 return resultobj;
40438 fail:
40439 return NULL;
40440 }
40441
40442
40443 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40444 PyObject *resultobj = 0;
40445 wxMenu *arg1 = (wxMenu *) 0 ;
40446 int arg2 ;
40447 wxString *arg3 = 0 ;
40448 void *argp1 = 0 ;
40449 int res1 = 0 ;
40450 int val2 ;
40451 int ecode2 = 0 ;
40452 bool temp3 = false ;
40453 PyObject * obj0 = 0 ;
40454 PyObject * obj1 = 0 ;
40455 PyObject * obj2 = 0 ;
40456 char * kwnames[] = {
40457 (char *) "self",(char *) "id",(char *) "helpString", NULL
40458 };
40459
40460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40462 if (!SWIG_IsOK(res1)) {
40463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40464 }
40465 arg1 = reinterpret_cast< wxMenu * >(argp1);
40466 ecode2 = SWIG_AsVal_int(obj1, &val2);
40467 if (!SWIG_IsOK(ecode2)) {
40468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40469 }
40470 arg2 = static_cast< int >(val2);
40471 {
40472 arg3 = wxString_in_helper(obj2);
40473 if (arg3 == NULL) SWIG_fail;
40474 temp3 = true;
40475 }
40476 {
40477 PyThreadState* __tstate = wxPyBeginAllowThreads();
40478 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40479 wxPyEndAllowThreads(__tstate);
40480 if (PyErr_Occurred()) SWIG_fail;
40481 }
40482 resultobj = SWIG_Py_Void();
40483 {
40484 if (temp3)
40485 delete arg3;
40486 }
40487 return resultobj;
40488 fail:
40489 {
40490 if (temp3)
40491 delete arg3;
40492 }
40493 return NULL;
40494 }
40495
40496
40497 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40498 PyObject *resultobj = 0;
40499 wxMenu *arg1 = (wxMenu *) 0 ;
40500 int arg2 ;
40501 wxString result;
40502 void *argp1 = 0 ;
40503 int res1 = 0 ;
40504 int val2 ;
40505 int ecode2 = 0 ;
40506 PyObject * obj0 = 0 ;
40507 PyObject * obj1 = 0 ;
40508 char * kwnames[] = {
40509 (char *) "self",(char *) "id", NULL
40510 };
40511
40512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40514 if (!SWIG_IsOK(res1)) {
40515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40516 }
40517 arg1 = reinterpret_cast< wxMenu * >(argp1);
40518 ecode2 = SWIG_AsVal_int(obj1, &val2);
40519 if (!SWIG_IsOK(ecode2)) {
40520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40521 }
40522 arg2 = static_cast< int >(val2);
40523 {
40524 PyThreadState* __tstate = wxPyBeginAllowThreads();
40525 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40526 wxPyEndAllowThreads(__tstate);
40527 if (PyErr_Occurred()) SWIG_fail;
40528 }
40529 {
40530 #if wxUSE_UNICODE
40531 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40532 #else
40533 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40534 #endif
40535 }
40536 return resultobj;
40537 fail:
40538 return NULL;
40539 }
40540
40541
40542 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40543 PyObject *resultobj = 0;
40544 wxMenu *arg1 = (wxMenu *) 0 ;
40545 wxString *arg2 = 0 ;
40546 void *argp1 = 0 ;
40547 int res1 = 0 ;
40548 bool temp2 = false ;
40549 PyObject * obj0 = 0 ;
40550 PyObject * obj1 = 0 ;
40551 char * kwnames[] = {
40552 (char *) "self",(char *) "title", NULL
40553 };
40554
40555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40557 if (!SWIG_IsOK(res1)) {
40558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40559 }
40560 arg1 = reinterpret_cast< wxMenu * >(argp1);
40561 {
40562 arg2 = wxString_in_helper(obj1);
40563 if (arg2 == NULL) SWIG_fail;
40564 temp2 = true;
40565 }
40566 {
40567 PyThreadState* __tstate = wxPyBeginAllowThreads();
40568 (arg1)->SetTitle((wxString const &)*arg2);
40569 wxPyEndAllowThreads(__tstate);
40570 if (PyErr_Occurred()) SWIG_fail;
40571 }
40572 resultobj = SWIG_Py_Void();
40573 {
40574 if (temp2)
40575 delete arg2;
40576 }
40577 return resultobj;
40578 fail:
40579 {
40580 if (temp2)
40581 delete arg2;
40582 }
40583 return NULL;
40584 }
40585
40586
40587 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40588 PyObject *resultobj = 0;
40589 wxMenu *arg1 = (wxMenu *) 0 ;
40590 wxString result;
40591 void *argp1 = 0 ;
40592 int res1 = 0 ;
40593 PyObject *swig_obj[1] ;
40594
40595 if (!args) SWIG_fail;
40596 swig_obj[0] = args;
40597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40598 if (!SWIG_IsOK(res1)) {
40599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40600 }
40601 arg1 = reinterpret_cast< wxMenu * >(argp1);
40602 {
40603 PyThreadState* __tstate = wxPyBeginAllowThreads();
40604 result = ((wxMenu const *)arg1)->GetTitle();
40605 wxPyEndAllowThreads(__tstate);
40606 if (PyErr_Occurred()) SWIG_fail;
40607 }
40608 {
40609 #if wxUSE_UNICODE
40610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40611 #else
40612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40613 #endif
40614 }
40615 return resultobj;
40616 fail:
40617 return NULL;
40618 }
40619
40620
40621 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40622 PyObject *resultobj = 0;
40623 wxMenu *arg1 = (wxMenu *) 0 ;
40624 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40625 void *argp1 = 0 ;
40626 int res1 = 0 ;
40627 void *argp2 = 0 ;
40628 int res2 = 0 ;
40629 PyObject * obj0 = 0 ;
40630 PyObject * obj1 = 0 ;
40631 char * kwnames[] = {
40632 (char *) "self",(char *) "handler", NULL
40633 };
40634
40635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40637 if (!SWIG_IsOK(res1)) {
40638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40639 }
40640 arg1 = reinterpret_cast< wxMenu * >(argp1);
40641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40642 if (!SWIG_IsOK(res2)) {
40643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40644 }
40645 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40646 {
40647 PyThreadState* __tstate = wxPyBeginAllowThreads();
40648 (arg1)->SetEventHandler(arg2);
40649 wxPyEndAllowThreads(__tstate);
40650 if (PyErr_Occurred()) SWIG_fail;
40651 }
40652 resultobj = SWIG_Py_Void();
40653 return resultobj;
40654 fail:
40655 return NULL;
40656 }
40657
40658
40659 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40660 PyObject *resultobj = 0;
40661 wxMenu *arg1 = (wxMenu *) 0 ;
40662 wxEvtHandler *result = 0 ;
40663 void *argp1 = 0 ;
40664 int res1 = 0 ;
40665 PyObject *swig_obj[1] ;
40666
40667 if (!args) SWIG_fail;
40668 swig_obj[0] = args;
40669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40670 if (!SWIG_IsOK(res1)) {
40671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40672 }
40673 arg1 = reinterpret_cast< wxMenu * >(argp1);
40674 {
40675 PyThreadState* __tstate = wxPyBeginAllowThreads();
40676 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40677 wxPyEndAllowThreads(__tstate);
40678 if (PyErr_Occurred()) SWIG_fail;
40679 }
40680 {
40681 resultobj = wxPyMake_wxObject(result, 0);
40682 }
40683 return resultobj;
40684 fail:
40685 return NULL;
40686 }
40687
40688
40689 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40690 PyObject *resultobj = 0;
40691 wxMenu *arg1 = (wxMenu *) 0 ;
40692 wxWindow *arg2 = (wxWindow *) 0 ;
40693 void *argp1 = 0 ;
40694 int res1 = 0 ;
40695 void *argp2 = 0 ;
40696 int res2 = 0 ;
40697 PyObject * obj0 = 0 ;
40698 PyObject * obj1 = 0 ;
40699 char * kwnames[] = {
40700 (char *) "self",(char *) "win", NULL
40701 };
40702
40703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40705 if (!SWIG_IsOK(res1)) {
40706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40707 }
40708 arg1 = reinterpret_cast< wxMenu * >(argp1);
40709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40710 if (!SWIG_IsOK(res2)) {
40711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40712 }
40713 arg2 = reinterpret_cast< wxWindow * >(argp2);
40714 {
40715 PyThreadState* __tstate = wxPyBeginAllowThreads();
40716 (arg1)->SetInvokingWindow(arg2);
40717 wxPyEndAllowThreads(__tstate);
40718 if (PyErr_Occurred()) SWIG_fail;
40719 }
40720 resultobj = SWIG_Py_Void();
40721 return resultobj;
40722 fail:
40723 return NULL;
40724 }
40725
40726
40727 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40728 PyObject *resultobj = 0;
40729 wxMenu *arg1 = (wxMenu *) 0 ;
40730 wxWindow *result = 0 ;
40731 void *argp1 = 0 ;
40732 int res1 = 0 ;
40733 PyObject *swig_obj[1] ;
40734
40735 if (!args) SWIG_fail;
40736 swig_obj[0] = args;
40737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40738 if (!SWIG_IsOK(res1)) {
40739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40740 }
40741 arg1 = reinterpret_cast< wxMenu * >(argp1);
40742 {
40743 PyThreadState* __tstate = wxPyBeginAllowThreads();
40744 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40745 wxPyEndAllowThreads(__tstate);
40746 if (PyErr_Occurred()) SWIG_fail;
40747 }
40748 {
40749 resultobj = wxPyMake_wxObject(result, 0);
40750 }
40751 return resultobj;
40752 fail:
40753 return NULL;
40754 }
40755
40756
40757 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40758 PyObject *resultobj = 0;
40759 wxMenu *arg1 = (wxMenu *) 0 ;
40760 long result;
40761 void *argp1 = 0 ;
40762 int res1 = 0 ;
40763 PyObject *swig_obj[1] ;
40764
40765 if (!args) SWIG_fail;
40766 swig_obj[0] = args;
40767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40768 if (!SWIG_IsOK(res1)) {
40769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40770 }
40771 arg1 = reinterpret_cast< wxMenu * >(argp1);
40772 {
40773 PyThreadState* __tstate = wxPyBeginAllowThreads();
40774 result = (long)((wxMenu const *)arg1)->GetStyle();
40775 wxPyEndAllowThreads(__tstate);
40776 if (PyErr_Occurred()) SWIG_fail;
40777 }
40778 resultobj = SWIG_From_long(static_cast< long >(result));
40779 return resultobj;
40780 fail:
40781 return NULL;
40782 }
40783
40784
40785 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40786 PyObject *resultobj = 0;
40787 wxMenu *arg1 = (wxMenu *) 0 ;
40788 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40789 void *argp1 = 0 ;
40790 int res1 = 0 ;
40791 void *argp2 = 0 ;
40792 int res2 = 0 ;
40793 PyObject * obj0 = 0 ;
40794 PyObject * obj1 = 0 ;
40795 char * kwnames[] = {
40796 (char *) "self",(char *) "source", NULL
40797 };
40798
40799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40801 if (!SWIG_IsOK(res1)) {
40802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40803 }
40804 arg1 = reinterpret_cast< wxMenu * >(argp1);
40805 if (obj1) {
40806 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40807 if (!SWIG_IsOK(res2)) {
40808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40809 }
40810 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40811 }
40812 {
40813 PyThreadState* __tstate = wxPyBeginAllowThreads();
40814 (arg1)->UpdateUI(arg2);
40815 wxPyEndAllowThreads(__tstate);
40816 if (PyErr_Occurred()) SWIG_fail;
40817 }
40818 resultobj = SWIG_Py_Void();
40819 return resultobj;
40820 fail:
40821 return NULL;
40822 }
40823
40824
40825 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40826 PyObject *resultobj = 0;
40827 wxMenu *arg1 = (wxMenu *) 0 ;
40828 wxMenuBar *result = 0 ;
40829 void *argp1 = 0 ;
40830 int res1 = 0 ;
40831 PyObject *swig_obj[1] ;
40832
40833 if (!args) SWIG_fail;
40834 swig_obj[0] = args;
40835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40836 if (!SWIG_IsOK(res1)) {
40837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40838 }
40839 arg1 = reinterpret_cast< wxMenu * >(argp1);
40840 {
40841 PyThreadState* __tstate = wxPyBeginAllowThreads();
40842 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40843 wxPyEndAllowThreads(__tstate);
40844 if (PyErr_Occurred()) SWIG_fail;
40845 }
40846 {
40847 resultobj = wxPyMake_wxObject(result, (bool)0);
40848 }
40849 return resultobj;
40850 fail:
40851 return NULL;
40852 }
40853
40854
40855 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40856 PyObject *resultobj = 0;
40857 wxMenu *arg1 = (wxMenu *) 0 ;
40858 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40859 void *argp1 = 0 ;
40860 int res1 = 0 ;
40861 void *argp2 = 0 ;
40862 int res2 = 0 ;
40863 PyObject * obj0 = 0 ;
40864 PyObject * obj1 = 0 ;
40865 char * kwnames[] = {
40866 (char *) "self",(char *) "menubar", NULL
40867 };
40868
40869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40871 if (!SWIG_IsOK(res1)) {
40872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40873 }
40874 arg1 = reinterpret_cast< wxMenu * >(argp1);
40875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40876 if (!SWIG_IsOK(res2)) {
40877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40878 }
40879 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40880 {
40881 PyThreadState* __tstate = wxPyBeginAllowThreads();
40882 (arg1)->Attach(arg2);
40883 wxPyEndAllowThreads(__tstate);
40884 if (PyErr_Occurred()) SWIG_fail;
40885 }
40886 resultobj = SWIG_Py_Void();
40887 return resultobj;
40888 fail:
40889 return NULL;
40890 }
40891
40892
40893 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40894 PyObject *resultobj = 0;
40895 wxMenu *arg1 = (wxMenu *) 0 ;
40896 void *argp1 = 0 ;
40897 int res1 = 0 ;
40898 PyObject *swig_obj[1] ;
40899
40900 if (!args) SWIG_fail;
40901 swig_obj[0] = args;
40902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40903 if (!SWIG_IsOK(res1)) {
40904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40905 }
40906 arg1 = reinterpret_cast< wxMenu * >(argp1);
40907 {
40908 PyThreadState* __tstate = wxPyBeginAllowThreads();
40909 (arg1)->Detach();
40910 wxPyEndAllowThreads(__tstate);
40911 if (PyErr_Occurred()) SWIG_fail;
40912 }
40913 resultobj = SWIG_Py_Void();
40914 return resultobj;
40915 fail:
40916 return NULL;
40917 }
40918
40919
40920 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40921 PyObject *resultobj = 0;
40922 wxMenu *arg1 = (wxMenu *) 0 ;
40923 bool result;
40924 void *argp1 = 0 ;
40925 int res1 = 0 ;
40926 PyObject *swig_obj[1] ;
40927
40928 if (!args) SWIG_fail;
40929 swig_obj[0] = args;
40930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40931 if (!SWIG_IsOK(res1)) {
40932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40933 }
40934 arg1 = reinterpret_cast< wxMenu * >(argp1);
40935 {
40936 PyThreadState* __tstate = wxPyBeginAllowThreads();
40937 result = (bool)((wxMenu const *)arg1)->IsAttached();
40938 wxPyEndAllowThreads(__tstate);
40939 if (PyErr_Occurred()) SWIG_fail;
40940 }
40941 {
40942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40943 }
40944 return resultobj;
40945 fail:
40946 return NULL;
40947 }
40948
40949
40950 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40951 PyObject *resultobj = 0;
40952 wxMenu *arg1 = (wxMenu *) 0 ;
40953 wxMenu *arg2 = (wxMenu *) 0 ;
40954 void *argp1 = 0 ;
40955 int res1 = 0 ;
40956 void *argp2 = 0 ;
40957 int res2 = 0 ;
40958 PyObject * obj0 = 0 ;
40959 PyObject * obj1 = 0 ;
40960 char * kwnames[] = {
40961 (char *) "self",(char *) "parent", NULL
40962 };
40963
40964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40966 if (!SWIG_IsOK(res1)) {
40967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40968 }
40969 arg1 = reinterpret_cast< wxMenu * >(argp1);
40970 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40971 if (!SWIG_IsOK(res2)) {
40972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40973 }
40974 arg2 = reinterpret_cast< wxMenu * >(argp2);
40975 {
40976 PyThreadState* __tstate = wxPyBeginAllowThreads();
40977 (arg1)->SetParent(arg2);
40978 wxPyEndAllowThreads(__tstate);
40979 if (PyErr_Occurred()) SWIG_fail;
40980 }
40981 resultobj = SWIG_Py_Void();
40982 return resultobj;
40983 fail:
40984 return NULL;
40985 }
40986
40987
40988 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40989 PyObject *resultobj = 0;
40990 wxMenu *arg1 = (wxMenu *) 0 ;
40991 wxMenu *result = 0 ;
40992 void *argp1 = 0 ;
40993 int res1 = 0 ;
40994 PyObject *swig_obj[1] ;
40995
40996 if (!args) SWIG_fail;
40997 swig_obj[0] = args;
40998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40999 if (!SWIG_IsOK(res1)) {
41000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41001 }
41002 arg1 = reinterpret_cast< wxMenu * >(argp1);
41003 {
41004 PyThreadState* __tstate = wxPyBeginAllowThreads();
41005 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41006 wxPyEndAllowThreads(__tstate);
41007 if (PyErr_Occurred()) SWIG_fail;
41008 }
41009 {
41010 resultobj = wxPyMake_wxObject(result, 0);
41011 }
41012 return resultobj;
41013 fail:
41014 return NULL;
41015 }
41016
41017
41018 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41019 PyObject *obj;
41020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41021 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41022 return SWIG_Py_Void();
41023 }
41024
41025 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41026 return SWIG_Python_InitShadowInstance(args);
41027 }
41028
41029 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41030 PyObject *resultobj = 0;
41031 long arg1 = (long) 0 ;
41032 wxMenuBar *result = 0 ;
41033 long val1 ;
41034 int ecode1 = 0 ;
41035 PyObject * obj0 = 0 ;
41036 char * kwnames[] = {
41037 (char *) "style", NULL
41038 };
41039
41040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41041 if (obj0) {
41042 ecode1 = SWIG_AsVal_long(obj0, &val1);
41043 if (!SWIG_IsOK(ecode1)) {
41044 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41045 }
41046 arg1 = static_cast< long >(val1);
41047 }
41048 {
41049 if (!wxPyCheckForApp()) SWIG_fail;
41050 PyThreadState* __tstate = wxPyBeginAllowThreads();
41051 result = (wxMenuBar *)new wxMenuBar(arg1);
41052 wxPyEndAllowThreads(__tstate);
41053 if (PyErr_Occurred()) SWIG_fail;
41054 }
41055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41056 return resultobj;
41057 fail:
41058 return NULL;
41059 }
41060
41061
41062 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41063 PyObject *resultobj = 0;
41064 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41065 wxMenu *arg2 = (wxMenu *) 0 ;
41066 wxString *arg3 = 0 ;
41067 bool result;
41068 void *argp1 = 0 ;
41069 int res1 = 0 ;
41070 void *argp2 = 0 ;
41071 int res2 = 0 ;
41072 bool temp3 = false ;
41073 PyObject * obj0 = 0 ;
41074 PyObject * obj1 = 0 ;
41075 PyObject * obj2 = 0 ;
41076 char * kwnames[] = {
41077 (char *) "self",(char *) "menu",(char *) "title", NULL
41078 };
41079
41080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41082 if (!SWIG_IsOK(res1)) {
41083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41084 }
41085 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41086 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41087 if (!SWIG_IsOK(res2)) {
41088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41089 }
41090 arg2 = reinterpret_cast< wxMenu * >(argp2);
41091 {
41092 arg3 = wxString_in_helper(obj2);
41093 if (arg3 == NULL) SWIG_fail;
41094 temp3 = true;
41095 }
41096 {
41097 PyThreadState* __tstate = wxPyBeginAllowThreads();
41098 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41099 wxPyEndAllowThreads(__tstate);
41100 if (PyErr_Occurred()) SWIG_fail;
41101 }
41102 {
41103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41104 }
41105 {
41106 if (temp3)
41107 delete arg3;
41108 }
41109 return resultobj;
41110 fail:
41111 {
41112 if (temp3)
41113 delete arg3;
41114 }
41115 return NULL;
41116 }
41117
41118
41119 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41120 PyObject *resultobj = 0;
41121 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41122 size_t arg2 ;
41123 wxMenu *arg3 = (wxMenu *) 0 ;
41124 wxString *arg4 = 0 ;
41125 bool result;
41126 void *argp1 = 0 ;
41127 int res1 = 0 ;
41128 size_t val2 ;
41129 int ecode2 = 0 ;
41130 void *argp3 = 0 ;
41131 int res3 = 0 ;
41132 bool temp4 = false ;
41133 PyObject * obj0 = 0 ;
41134 PyObject * obj1 = 0 ;
41135 PyObject * obj2 = 0 ;
41136 PyObject * obj3 = 0 ;
41137 char * kwnames[] = {
41138 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41139 };
41140
41141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41143 if (!SWIG_IsOK(res1)) {
41144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41145 }
41146 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41147 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41148 if (!SWIG_IsOK(ecode2)) {
41149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41150 }
41151 arg2 = static_cast< size_t >(val2);
41152 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41153 if (!SWIG_IsOK(res3)) {
41154 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41155 }
41156 arg3 = reinterpret_cast< wxMenu * >(argp3);
41157 {
41158 arg4 = wxString_in_helper(obj3);
41159 if (arg4 == NULL) SWIG_fail;
41160 temp4 = true;
41161 }
41162 {
41163 PyThreadState* __tstate = wxPyBeginAllowThreads();
41164 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41165 wxPyEndAllowThreads(__tstate);
41166 if (PyErr_Occurred()) SWIG_fail;
41167 }
41168 {
41169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41170 }
41171 {
41172 if (temp4)
41173 delete arg4;
41174 }
41175 return resultobj;
41176 fail:
41177 {
41178 if (temp4)
41179 delete arg4;
41180 }
41181 return NULL;
41182 }
41183
41184
41185 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41186 PyObject *resultobj = 0;
41187 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41188 size_t result;
41189 void *argp1 = 0 ;
41190 int res1 = 0 ;
41191 PyObject *swig_obj[1] ;
41192
41193 if (!args) SWIG_fail;
41194 swig_obj[0] = args;
41195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41196 if (!SWIG_IsOK(res1)) {
41197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41198 }
41199 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41200 {
41201 PyThreadState* __tstate = wxPyBeginAllowThreads();
41202 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41203 wxPyEndAllowThreads(__tstate);
41204 if (PyErr_Occurred()) SWIG_fail;
41205 }
41206 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41207 return resultobj;
41208 fail:
41209 return NULL;
41210 }
41211
41212
41213 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41214 PyObject *resultobj = 0;
41215 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41216 size_t arg2 ;
41217 wxMenu *result = 0 ;
41218 void *argp1 = 0 ;
41219 int res1 = 0 ;
41220 size_t val2 ;
41221 int ecode2 = 0 ;
41222 PyObject * obj0 = 0 ;
41223 PyObject * obj1 = 0 ;
41224 char * kwnames[] = {
41225 (char *) "self",(char *) "pos", NULL
41226 };
41227
41228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41230 if (!SWIG_IsOK(res1)) {
41231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41232 }
41233 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41234 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41235 if (!SWIG_IsOK(ecode2)) {
41236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41237 }
41238 arg2 = static_cast< size_t >(val2);
41239 {
41240 PyThreadState* __tstate = wxPyBeginAllowThreads();
41241 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41242 wxPyEndAllowThreads(__tstate);
41243 if (PyErr_Occurred()) SWIG_fail;
41244 }
41245 {
41246 resultobj = wxPyMake_wxObject(result, 0);
41247 }
41248 return resultobj;
41249 fail:
41250 return NULL;
41251 }
41252
41253
41254 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41255 PyObject *resultobj = 0;
41256 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41257 size_t arg2 ;
41258 wxMenu *arg3 = (wxMenu *) 0 ;
41259 wxString *arg4 = 0 ;
41260 wxMenu *result = 0 ;
41261 void *argp1 = 0 ;
41262 int res1 = 0 ;
41263 size_t val2 ;
41264 int ecode2 = 0 ;
41265 void *argp3 = 0 ;
41266 int res3 = 0 ;
41267 bool temp4 = false ;
41268 PyObject * obj0 = 0 ;
41269 PyObject * obj1 = 0 ;
41270 PyObject * obj2 = 0 ;
41271 PyObject * obj3 = 0 ;
41272 char * kwnames[] = {
41273 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41274 };
41275
41276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41278 if (!SWIG_IsOK(res1)) {
41279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41280 }
41281 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41282 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41283 if (!SWIG_IsOK(ecode2)) {
41284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41285 }
41286 arg2 = static_cast< size_t >(val2);
41287 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41288 if (!SWIG_IsOK(res3)) {
41289 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41290 }
41291 arg3 = reinterpret_cast< wxMenu * >(argp3);
41292 {
41293 arg4 = wxString_in_helper(obj3);
41294 if (arg4 == NULL) SWIG_fail;
41295 temp4 = true;
41296 }
41297 {
41298 PyThreadState* __tstate = wxPyBeginAllowThreads();
41299 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41300 wxPyEndAllowThreads(__tstate);
41301 if (PyErr_Occurred()) SWIG_fail;
41302 }
41303 {
41304 resultobj = wxPyMake_wxObject(result, 0);
41305 }
41306 {
41307 if (temp4)
41308 delete arg4;
41309 }
41310 return resultobj;
41311 fail:
41312 {
41313 if (temp4)
41314 delete arg4;
41315 }
41316 return NULL;
41317 }
41318
41319
41320 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41321 PyObject *resultobj = 0;
41322 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41323 size_t arg2 ;
41324 wxMenu *result = 0 ;
41325 void *argp1 = 0 ;
41326 int res1 = 0 ;
41327 size_t val2 ;
41328 int ecode2 = 0 ;
41329 PyObject * obj0 = 0 ;
41330 PyObject * obj1 = 0 ;
41331 char * kwnames[] = {
41332 (char *) "self",(char *) "pos", NULL
41333 };
41334
41335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41337 if (!SWIG_IsOK(res1)) {
41338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41339 }
41340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41341 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41342 if (!SWIG_IsOK(ecode2)) {
41343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41344 }
41345 arg2 = static_cast< size_t >(val2);
41346 {
41347 PyThreadState* __tstate = wxPyBeginAllowThreads();
41348 result = (wxMenu *)(arg1)->Remove(arg2);
41349 wxPyEndAllowThreads(__tstate);
41350 if (PyErr_Occurred()) SWIG_fail;
41351 }
41352 {
41353 resultobj = wxPyMake_wxObject(result, 0);
41354 }
41355 return resultobj;
41356 fail:
41357 return NULL;
41358 }
41359
41360
41361 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41362 PyObject *resultobj = 0;
41363 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41364 size_t arg2 ;
41365 bool arg3 ;
41366 void *argp1 = 0 ;
41367 int res1 = 0 ;
41368 size_t val2 ;
41369 int ecode2 = 0 ;
41370 bool val3 ;
41371 int ecode3 = 0 ;
41372 PyObject * obj0 = 0 ;
41373 PyObject * obj1 = 0 ;
41374 PyObject * obj2 = 0 ;
41375 char * kwnames[] = {
41376 (char *) "self",(char *) "pos",(char *) "enable", NULL
41377 };
41378
41379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41381 if (!SWIG_IsOK(res1)) {
41382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41383 }
41384 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41385 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41386 if (!SWIG_IsOK(ecode2)) {
41387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41388 }
41389 arg2 = static_cast< size_t >(val2);
41390 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41391 if (!SWIG_IsOK(ecode3)) {
41392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41393 }
41394 arg3 = static_cast< bool >(val3);
41395 {
41396 PyThreadState* __tstate = wxPyBeginAllowThreads();
41397 (arg1)->EnableTop(arg2,arg3);
41398 wxPyEndAllowThreads(__tstate);
41399 if (PyErr_Occurred()) SWIG_fail;
41400 }
41401 resultobj = SWIG_Py_Void();
41402 return resultobj;
41403 fail:
41404 return NULL;
41405 }
41406
41407
41408 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41409 PyObject *resultobj = 0;
41410 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41411 size_t arg2 ;
41412 bool result;
41413 void *argp1 = 0 ;
41414 int res1 = 0 ;
41415 size_t val2 ;
41416 int ecode2 = 0 ;
41417 PyObject * obj0 = 0 ;
41418 PyObject * obj1 = 0 ;
41419 char * kwnames[] = {
41420 (char *) "self",(char *) "pos", NULL
41421 };
41422
41423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41425 if (!SWIG_IsOK(res1)) {
41426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41427 }
41428 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41429 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41430 if (!SWIG_IsOK(ecode2)) {
41431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41432 }
41433 arg2 = static_cast< size_t >(val2);
41434 {
41435 PyThreadState* __tstate = wxPyBeginAllowThreads();
41436 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41437 wxPyEndAllowThreads(__tstate);
41438 if (PyErr_Occurred()) SWIG_fail;
41439 }
41440 {
41441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41442 }
41443 return resultobj;
41444 fail:
41445 return NULL;
41446 }
41447
41448
41449 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41450 PyObject *resultobj = 0;
41451 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41452 size_t arg2 ;
41453 wxString *arg3 = 0 ;
41454 void *argp1 = 0 ;
41455 int res1 = 0 ;
41456 size_t val2 ;
41457 int ecode2 = 0 ;
41458 bool temp3 = false ;
41459 PyObject * obj0 = 0 ;
41460 PyObject * obj1 = 0 ;
41461 PyObject * obj2 = 0 ;
41462 char * kwnames[] = {
41463 (char *) "self",(char *) "pos",(char *) "label", NULL
41464 };
41465
41466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41468 if (!SWIG_IsOK(res1)) {
41469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41470 }
41471 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41472 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41473 if (!SWIG_IsOK(ecode2)) {
41474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41475 }
41476 arg2 = static_cast< size_t >(val2);
41477 {
41478 arg3 = wxString_in_helper(obj2);
41479 if (arg3 == NULL) SWIG_fail;
41480 temp3 = true;
41481 }
41482 {
41483 PyThreadState* __tstate = wxPyBeginAllowThreads();
41484 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41485 wxPyEndAllowThreads(__tstate);
41486 if (PyErr_Occurred()) SWIG_fail;
41487 }
41488 resultobj = SWIG_Py_Void();
41489 {
41490 if (temp3)
41491 delete arg3;
41492 }
41493 return resultobj;
41494 fail:
41495 {
41496 if (temp3)
41497 delete arg3;
41498 }
41499 return NULL;
41500 }
41501
41502
41503 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41504 PyObject *resultobj = 0;
41505 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41506 size_t arg2 ;
41507 wxString result;
41508 void *argp1 = 0 ;
41509 int res1 = 0 ;
41510 size_t val2 ;
41511 int ecode2 = 0 ;
41512 PyObject * obj0 = 0 ;
41513 PyObject * obj1 = 0 ;
41514 char * kwnames[] = {
41515 (char *) "self",(char *) "pos", NULL
41516 };
41517
41518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41520 if (!SWIG_IsOK(res1)) {
41521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41522 }
41523 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41524 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41525 if (!SWIG_IsOK(ecode2)) {
41526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41527 }
41528 arg2 = static_cast< size_t >(val2);
41529 {
41530 PyThreadState* __tstate = wxPyBeginAllowThreads();
41531 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41532 wxPyEndAllowThreads(__tstate);
41533 if (PyErr_Occurred()) SWIG_fail;
41534 }
41535 {
41536 #if wxUSE_UNICODE
41537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41538 #else
41539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41540 #endif
41541 }
41542 return resultobj;
41543 fail:
41544 return NULL;
41545 }
41546
41547
41548 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41549 PyObject *resultobj = 0;
41550 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41551 wxString *arg2 = 0 ;
41552 wxString *arg3 = 0 ;
41553 int result;
41554 void *argp1 = 0 ;
41555 int res1 = 0 ;
41556 bool temp2 = false ;
41557 bool temp3 = false ;
41558 PyObject * obj0 = 0 ;
41559 PyObject * obj1 = 0 ;
41560 PyObject * obj2 = 0 ;
41561 char * kwnames[] = {
41562 (char *) "self",(char *) "menu",(char *) "item", NULL
41563 };
41564
41565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41567 if (!SWIG_IsOK(res1)) {
41568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41569 }
41570 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41571 {
41572 arg2 = wxString_in_helper(obj1);
41573 if (arg2 == NULL) SWIG_fail;
41574 temp2 = true;
41575 }
41576 {
41577 arg3 = wxString_in_helper(obj2);
41578 if (arg3 == NULL) SWIG_fail;
41579 temp3 = true;
41580 }
41581 {
41582 PyThreadState* __tstate = wxPyBeginAllowThreads();
41583 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41584 wxPyEndAllowThreads(__tstate);
41585 if (PyErr_Occurred()) SWIG_fail;
41586 }
41587 resultobj = SWIG_From_int(static_cast< int >(result));
41588 {
41589 if (temp2)
41590 delete arg2;
41591 }
41592 {
41593 if (temp3)
41594 delete arg3;
41595 }
41596 return resultobj;
41597 fail:
41598 {
41599 if (temp2)
41600 delete arg2;
41601 }
41602 {
41603 if (temp3)
41604 delete arg3;
41605 }
41606 return NULL;
41607 }
41608
41609
41610 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41611 PyObject *resultobj = 0;
41612 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41613 int arg2 ;
41614 wxMenuItem *result = 0 ;
41615 void *argp1 = 0 ;
41616 int res1 = 0 ;
41617 int val2 ;
41618 int ecode2 = 0 ;
41619 PyObject * obj0 = 0 ;
41620 PyObject * obj1 = 0 ;
41621 char * kwnames[] = {
41622 (char *) "self",(char *) "id", NULL
41623 };
41624
41625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41627 if (!SWIG_IsOK(res1)) {
41628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41629 }
41630 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41631 ecode2 = SWIG_AsVal_int(obj1, &val2);
41632 if (!SWIG_IsOK(ecode2)) {
41633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41634 }
41635 arg2 = static_cast< int >(val2);
41636 {
41637 PyThreadState* __tstate = wxPyBeginAllowThreads();
41638 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41639 wxPyEndAllowThreads(__tstate);
41640 if (PyErr_Occurred()) SWIG_fail;
41641 }
41642 {
41643 resultobj = wxPyMake_wxObject(result, (bool)0);
41644 }
41645 return resultobj;
41646 fail:
41647 return NULL;
41648 }
41649
41650
41651 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41652 PyObject *resultobj = 0;
41653 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41654 wxString *arg2 = 0 ;
41655 int result;
41656 void *argp1 = 0 ;
41657 int res1 = 0 ;
41658 bool temp2 = false ;
41659 PyObject * obj0 = 0 ;
41660 PyObject * obj1 = 0 ;
41661 char * kwnames[] = {
41662 (char *) "self",(char *) "title", NULL
41663 };
41664
41665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41667 if (!SWIG_IsOK(res1)) {
41668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41669 }
41670 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41671 {
41672 arg2 = wxString_in_helper(obj1);
41673 if (arg2 == NULL) SWIG_fail;
41674 temp2 = true;
41675 }
41676 {
41677 PyThreadState* __tstate = wxPyBeginAllowThreads();
41678 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41679 wxPyEndAllowThreads(__tstate);
41680 if (PyErr_Occurred()) SWIG_fail;
41681 }
41682 resultobj = SWIG_From_int(static_cast< int >(result));
41683 {
41684 if (temp2)
41685 delete arg2;
41686 }
41687 return resultobj;
41688 fail:
41689 {
41690 if (temp2)
41691 delete arg2;
41692 }
41693 return NULL;
41694 }
41695
41696
41697 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41698 PyObject *resultobj = 0;
41699 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41700 int arg2 ;
41701 bool arg3 ;
41702 void *argp1 = 0 ;
41703 int res1 = 0 ;
41704 int val2 ;
41705 int ecode2 = 0 ;
41706 bool val3 ;
41707 int ecode3 = 0 ;
41708 PyObject * obj0 = 0 ;
41709 PyObject * obj1 = 0 ;
41710 PyObject * obj2 = 0 ;
41711 char * kwnames[] = {
41712 (char *) "self",(char *) "id",(char *) "enable", NULL
41713 };
41714
41715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41717 if (!SWIG_IsOK(res1)) {
41718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41719 }
41720 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41721 ecode2 = SWIG_AsVal_int(obj1, &val2);
41722 if (!SWIG_IsOK(ecode2)) {
41723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41724 }
41725 arg2 = static_cast< int >(val2);
41726 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41727 if (!SWIG_IsOK(ecode3)) {
41728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41729 }
41730 arg3 = static_cast< bool >(val3);
41731 {
41732 PyThreadState* __tstate = wxPyBeginAllowThreads();
41733 (arg1)->Enable(arg2,arg3);
41734 wxPyEndAllowThreads(__tstate);
41735 if (PyErr_Occurred()) SWIG_fail;
41736 }
41737 resultobj = SWIG_Py_Void();
41738 return resultobj;
41739 fail:
41740 return NULL;
41741 }
41742
41743
41744 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41745 PyObject *resultobj = 0;
41746 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41747 int arg2 ;
41748 bool arg3 ;
41749 void *argp1 = 0 ;
41750 int res1 = 0 ;
41751 int val2 ;
41752 int ecode2 = 0 ;
41753 bool val3 ;
41754 int ecode3 = 0 ;
41755 PyObject * obj0 = 0 ;
41756 PyObject * obj1 = 0 ;
41757 PyObject * obj2 = 0 ;
41758 char * kwnames[] = {
41759 (char *) "self",(char *) "id",(char *) "check", NULL
41760 };
41761
41762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41764 if (!SWIG_IsOK(res1)) {
41765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41766 }
41767 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41768 ecode2 = SWIG_AsVal_int(obj1, &val2);
41769 if (!SWIG_IsOK(ecode2)) {
41770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41771 }
41772 arg2 = static_cast< int >(val2);
41773 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41774 if (!SWIG_IsOK(ecode3)) {
41775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41776 }
41777 arg3 = static_cast< bool >(val3);
41778 {
41779 PyThreadState* __tstate = wxPyBeginAllowThreads();
41780 (arg1)->Check(arg2,arg3);
41781 wxPyEndAllowThreads(__tstate);
41782 if (PyErr_Occurred()) SWIG_fail;
41783 }
41784 resultobj = SWIG_Py_Void();
41785 return resultobj;
41786 fail:
41787 return NULL;
41788 }
41789
41790
41791 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41792 PyObject *resultobj = 0;
41793 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41794 int arg2 ;
41795 bool result;
41796 void *argp1 = 0 ;
41797 int res1 = 0 ;
41798 int val2 ;
41799 int ecode2 = 0 ;
41800 PyObject * obj0 = 0 ;
41801 PyObject * obj1 = 0 ;
41802 char * kwnames[] = {
41803 (char *) "self",(char *) "id", NULL
41804 };
41805
41806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41808 if (!SWIG_IsOK(res1)) {
41809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41810 }
41811 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41812 ecode2 = SWIG_AsVal_int(obj1, &val2);
41813 if (!SWIG_IsOK(ecode2)) {
41814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41815 }
41816 arg2 = static_cast< int >(val2);
41817 {
41818 PyThreadState* __tstate = wxPyBeginAllowThreads();
41819 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41820 wxPyEndAllowThreads(__tstate);
41821 if (PyErr_Occurred()) SWIG_fail;
41822 }
41823 {
41824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41825 }
41826 return resultobj;
41827 fail:
41828 return NULL;
41829 }
41830
41831
41832 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41833 PyObject *resultobj = 0;
41834 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41835 int arg2 ;
41836 bool result;
41837 void *argp1 = 0 ;
41838 int res1 = 0 ;
41839 int val2 ;
41840 int ecode2 = 0 ;
41841 PyObject * obj0 = 0 ;
41842 PyObject * obj1 = 0 ;
41843 char * kwnames[] = {
41844 (char *) "self",(char *) "id", NULL
41845 };
41846
41847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41849 if (!SWIG_IsOK(res1)) {
41850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41851 }
41852 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41853 ecode2 = SWIG_AsVal_int(obj1, &val2);
41854 if (!SWIG_IsOK(ecode2)) {
41855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41856 }
41857 arg2 = static_cast< int >(val2);
41858 {
41859 PyThreadState* __tstate = wxPyBeginAllowThreads();
41860 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41861 wxPyEndAllowThreads(__tstate);
41862 if (PyErr_Occurred()) SWIG_fail;
41863 }
41864 {
41865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41866 }
41867 return resultobj;
41868 fail:
41869 return NULL;
41870 }
41871
41872
41873 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41874 PyObject *resultobj = 0;
41875 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41876 int arg2 ;
41877 wxString *arg3 = 0 ;
41878 void *argp1 = 0 ;
41879 int res1 = 0 ;
41880 int val2 ;
41881 int ecode2 = 0 ;
41882 bool temp3 = false ;
41883 PyObject * obj0 = 0 ;
41884 PyObject * obj1 = 0 ;
41885 PyObject * obj2 = 0 ;
41886 char * kwnames[] = {
41887 (char *) "self",(char *) "id",(char *) "label", NULL
41888 };
41889
41890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41892 if (!SWIG_IsOK(res1)) {
41893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41894 }
41895 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41896 ecode2 = SWIG_AsVal_int(obj1, &val2);
41897 if (!SWIG_IsOK(ecode2)) {
41898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41899 }
41900 arg2 = static_cast< int >(val2);
41901 {
41902 arg3 = wxString_in_helper(obj2);
41903 if (arg3 == NULL) SWIG_fail;
41904 temp3 = true;
41905 }
41906 {
41907 PyThreadState* __tstate = wxPyBeginAllowThreads();
41908 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41909 wxPyEndAllowThreads(__tstate);
41910 if (PyErr_Occurred()) SWIG_fail;
41911 }
41912 resultobj = SWIG_Py_Void();
41913 {
41914 if (temp3)
41915 delete arg3;
41916 }
41917 return resultobj;
41918 fail:
41919 {
41920 if (temp3)
41921 delete arg3;
41922 }
41923 return NULL;
41924 }
41925
41926
41927 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41928 PyObject *resultobj = 0;
41929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41930 int arg2 ;
41931 wxString result;
41932 void *argp1 = 0 ;
41933 int res1 = 0 ;
41934 int val2 ;
41935 int ecode2 = 0 ;
41936 PyObject * obj0 = 0 ;
41937 PyObject * obj1 = 0 ;
41938 char * kwnames[] = {
41939 (char *) "self",(char *) "id", NULL
41940 };
41941
41942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41944 if (!SWIG_IsOK(res1)) {
41945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41946 }
41947 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41948 ecode2 = SWIG_AsVal_int(obj1, &val2);
41949 if (!SWIG_IsOK(ecode2)) {
41950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41951 }
41952 arg2 = static_cast< int >(val2);
41953 {
41954 PyThreadState* __tstate = wxPyBeginAllowThreads();
41955 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41956 wxPyEndAllowThreads(__tstate);
41957 if (PyErr_Occurred()) SWIG_fail;
41958 }
41959 {
41960 #if wxUSE_UNICODE
41961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41962 #else
41963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41964 #endif
41965 }
41966 return resultobj;
41967 fail:
41968 return NULL;
41969 }
41970
41971
41972 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41973 PyObject *resultobj = 0;
41974 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41975 int arg2 ;
41976 wxString *arg3 = 0 ;
41977 void *argp1 = 0 ;
41978 int res1 = 0 ;
41979 int val2 ;
41980 int ecode2 = 0 ;
41981 bool temp3 = false ;
41982 PyObject * obj0 = 0 ;
41983 PyObject * obj1 = 0 ;
41984 PyObject * obj2 = 0 ;
41985 char * kwnames[] = {
41986 (char *) "self",(char *) "id",(char *) "helpString", NULL
41987 };
41988
41989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41991 if (!SWIG_IsOK(res1)) {
41992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41993 }
41994 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41995 ecode2 = SWIG_AsVal_int(obj1, &val2);
41996 if (!SWIG_IsOK(ecode2)) {
41997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41998 }
41999 arg2 = static_cast< int >(val2);
42000 {
42001 arg3 = wxString_in_helper(obj2);
42002 if (arg3 == NULL) SWIG_fail;
42003 temp3 = true;
42004 }
42005 {
42006 PyThreadState* __tstate = wxPyBeginAllowThreads();
42007 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42008 wxPyEndAllowThreads(__tstate);
42009 if (PyErr_Occurred()) SWIG_fail;
42010 }
42011 resultobj = SWIG_Py_Void();
42012 {
42013 if (temp3)
42014 delete arg3;
42015 }
42016 return resultobj;
42017 fail:
42018 {
42019 if (temp3)
42020 delete arg3;
42021 }
42022 return NULL;
42023 }
42024
42025
42026 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42027 PyObject *resultobj = 0;
42028 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42029 int arg2 ;
42030 wxString result;
42031 void *argp1 = 0 ;
42032 int res1 = 0 ;
42033 int val2 ;
42034 int ecode2 = 0 ;
42035 PyObject * obj0 = 0 ;
42036 PyObject * obj1 = 0 ;
42037 char * kwnames[] = {
42038 (char *) "self",(char *) "id", NULL
42039 };
42040
42041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42043 if (!SWIG_IsOK(res1)) {
42044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42045 }
42046 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42047 ecode2 = SWIG_AsVal_int(obj1, &val2);
42048 if (!SWIG_IsOK(ecode2)) {
42049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42050 }
42051 arg2 = static_cast< int >(val2);
42052 {
42053 PyThreadState* __tstate = wxPyBeginAllowThreads();
42054 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42055 wxPyEndAllowThreads(__tstate);
42056 if (PyErr_Occurred()) SWIG_fail;
42057 }
42058 {
42059 #if wxUSE_UNICODE
42060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42061 #else
42062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42063 #endif
42064 }
42065 return resultobj;
42066 fail:
42067 return NULL;
42068 }
42069
42070
42071 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42072 PyObject *resultobj = 0;
42073 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42074 wxFrame *result = 0 ;
42075 void *argp1 = 0 ;
42076 int res1 = 0 ;
42077 PyObject *swig_obj[1] ;
42078
42079 if (!args) SWIG_fail;
42080 swig_obj[0] = args;
42081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42082 if (!SWIG_IsOK(res1)) {
42083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42084 }
42085 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42086 {
42087 PyThreadState* __tstate = wxPyBeginAllowThreads();
42088 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42089 wxPyEndAllowThreads(__tstate);
42090 if (PyErr_Occurred()) SWIG_fail;
42091 }
42092 {
42093 resultobj = wxPyMake_wxObject(result, (bool)0);
42094 }
42095 return resultobj;
42096 fail:
42097 return NULL;
42098 }
42099
42100
42101 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42102 PyObject *resultobj = 0;
42103 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42104 bool result;
42105 void *argp1 = 0 ;
42106 int res1 = 0 ;
42107 PyObject *swig_obj[1] ;
42108
42109 if (!args) SWIG_fail;
42110 swig_obj[0] = args;
42111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42112 if (!SWIG_IsOK(res1)) {
42113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42114 }
42115 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42116 {
42117 PyThreadState* __tstate = wxPyBeginAllowThreads();
42118 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42119 wxPyEndAllowThreads(__tstate);
42120 if (PyErr_Occurred()) SWIG_fail;
42121 }
42122 {
42123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42124 }
42125 return resultobj;
42126 fail:
42127 return NULL;
42128 }
42129
42130
42131 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42132 PyObject *resultobj = 0;
42133 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42134 wxFrame *arg2 = (wxFrame *) 0 ;
42135 void *argp1 = 0 ;
42136 int res1 = 0 ;
42137 void *argp2 = 0 ;
42138 int res2 = 0 ;
42139 PyObject * obj0 = 0 ;
42140 PyObject * obj1 = 0 ;
42141 char * kwnames[] = {
42142 (char *) "self",(char *) "frame", NULL
42143 };
42144
42145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42147 if (!SWIG_IsOK(res1)) {
42148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42149 }
42150 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42151 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42152 if (!SWIG_IsOK(res2)) {
42153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42154 }
42155 arg2 = reinterpret_cast< wxFrame * >(argp2);
42156 {
42157 PyThreadState* __tstate = wxPyBeginAllowThreads();
42158 (arg1)->Attach(arg2);
42159 wxPyEndAllowThreads(__tstate);
42160 if (PyErr_Occurred()) SWIG_fail;
42161 }
42162 resultobj = SWIG_Py_Void();
42163 return resultobj;
42164 fail:
42165 return NULL;
42166 }
42167
42168
42169 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42170 PyObject *resultobj = 0;
42171 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42172 void *argp1 = 0 ;
42173 int res1 = 0 ;
42174 PyObject *swig_obj[1] ;
42175
42176 if (!args) SWIG_fail;
42177 swig_obj[0] = args;
42178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42179 if (!SWIG_IsOK(res1)) {
42180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42181 }
42182 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42183 {
42184 PyThreadState* __tstate = wxPyBeginAllowThreads();
42185 (arg1)->Detach();
42186 wxPyEndAllowThreads(__tstate);
42187 if (PyErr_Occurred()) SWIG_fail;
42188 }
42189 resultobj = SWIG_Py_Void();
42190 return resultobj;
42191 fail:
42192 return NULL;
42193 }
42194
42195
42196 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42197 PyObject *resultobj = 0;
42198 bool arg1 ;
42199 bool val1 ;
42200 int ecode1 = 0 ;
42201 PyObject * obj0 = 0 ;
42202 char * kwnames[] = {
42203 (char *) "enable", NULL
42204 };
42205
42206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42207 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42208 if (!SWIG_IsOK(ecode1)) {
42209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42210 }
42211 arg1 = static_cast< bool >(val1);
42212 {
42213 PyThreadState* __tstate = wxPyBeginAllowThreads();
42214 wxMenuBar_SetAutoWindowMenu(arg1);
42215 wxPyEndAllowThreads(__tstate);
42216 if (PyErr_Occurred()) SWIG_fail;
42217 }
42218 resultobj = SWIG_Py_Void();
42219 return resultobj;
42220 fail:
42221 return NULL;
42222 }
42223
42224
42225 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42226 PyObject *resultobj = 0;
42227 bool result;
42228
42229 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 result = (bool)wxMenuBar_GetAutoWindowMenu();
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 {
42237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42238 }
42239 return resultobj;
42240 fail:
42241 return NULL;
42242 }
42243
42244
42245 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42246 PyObject *obj;
42247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42248 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42249 return SWIG_Py_Void();
42250 }
42251
42252 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42253 return SWIG_Python_InitShadowInstance(args);
42254 }
42255
42256 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42257 PyObject *resultobj = 0;
42258 wxMenu *arg1 = (wxMenu *) NULL ;
42259 int arg2 = (int) wxID_ANY ;
42260 wxString const &arg3_defvalue = wxPyEmptyString ;
42261 wxString *arg3 = (wxString *) &arg3_defvalue ;
42262 wxString const &arg4_defvalue = wxPyEmptyString ;
42263 wxString *arg4 = (wxString *) &arg4_defvalue ;
42264 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42265 wxMenu *arg6 = (wxMenu *) NULL ;
42266 wxMenuItem *result = 0 ;
42267 void *argp1 = 0 ;
42268 int res1 = 0 ;
42269 int val2 ;
42270 int ecode2 = 0 ;
42271 bool temp3 = false ;
42272 bool temp4 = false ;
42273 int val5 ;
42274 int ecode5 = 0 ;
42275 void *argp6 = 0 ;
42276 int res6 = 0 ;
42277 PyObject * obj0 = 0 ;
42278 PyObject * obj1 = 0 ;
42279 PyObject * obj2 = 0 ;
42280 PyObject * obj3 = 0 ;
42281 PyObject * obj4 = 0 ;
42282 PyObject * obj5 = 0 ;
42283 char * kwnames[] = {
42284 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42285 };
42286
42287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42288 if (obj0) {
42289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42290 if (!SWIG_IsOK(res1)) {
42291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42292 }
42293 arg1 = reinterpret_cast< wxMenu * >(argp1);
42294 }
42295 if (obj1) {
42296 ecode2 = SWIG_AsVal_int(obj1, &val2);
42297 if (!SWIG_IsOK(ecode2)) {
42298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42299 }
42300 arg2 = static_cast< int >(val2);
42301 }
42302 if (obj2) {
42303 {
42304 arg3 = wxString_in_helper(obj2);
42305 if (arg3 == NULL) SWIG_fail;
42306 temp3 = true;
42307 }
42308 }
42309 if (obj3) {
42310 {
42311 arg4 = wxString_in_helper(obj3);
42312 if (arg4 == NULL) SWIG_fail;
42313 temp4 = true;
42314 }
42315 }
42316 if (obj4) {
42317 ecode5 = SWIG_AsVal_int(obj4, &val5);
42318 if (!SWIG_IsOK(ecode5)) {
42319 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42320 }
42321 arg5 = static_cast< wxItemKind >(val5);
42322 }
42323 if (obj5) {
42324 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42325 if (!SWIG_IsOK(res6)) {
42326 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42327 }
42328 arg6 = reinterpret_cast< wxMenu * >(argp6);
42329 }
42330 {
42331 PyThreadState* __tstate = wxPyBeginAllowThreads();
42332 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42333 wxPyEndAllowThreads(__tstate);
42334 if (PyErr_Occurred()) SWIG_fail;
42335 }
42336 {
42337 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42338 }
42339 {
42340 if (temp3)
42341 delete arg3;
42342 }
42343 {
42344 if (temp4)
42345 delete arg4;
42346 }
42347 return resultobj;
42348 fail:
42349 {
42350 if (temp3)
42351 delete arg3;
42352 }
42353 {
42354 if (temp4)
42355 delete arg4;
42356 }
42357 return NULL;
42358 }
42359
42360
42361 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42362 PyObject *resultobj = 0;
42363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42364 void *argp1 = 0 ;
42365 int res1 = 0 ;
42366 PyObject *swig_obj[1] ;
42367
42368 if (!args) SWIG_fail;
42369 swig_obj[0] = args;
42370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42371 if (!SWIG_IsOK(res1)) {
42372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42373 }
42374 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42375 {
42376 PyThreadState* __tstate = wxPyBeginAllowThreads();
42377 delete arg1;
42378
42379 wxPyEndAllowThreads(__tstate);
42380 if (PyErr_Occurred()) SWIG_fail;
42381 }
42382 resultobj = SWIG_Py_Void();
42383 return resultobj;
42384 fail:
42385 return NULL;
42386 }
42387
42388
42389 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42390 PyObject *resultobj = 0;
42391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42392 wxMenu *result = 0 ;
42393 void *argp1 = 0 ;
42394 int res1 = 0 ;
42395 PyObject *swig_obj[1] ;
42396
42397 if (!args) SWIG_fail;
42398 swig_obj[0] = args;
42399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42400 if (!SWIG_IsOK(res1)) {
42401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42402 }
42403 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42404 {
42405 PyThreadState* __tstate = wxPyBeginAllowThreads();
42406 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42407 wxPyEndAllowThreads(__tstate);
42408 if (PyErr_Occurred()) SWIG_fail;
42409 }
42410 {
42411 resultobj = wxPyMake_wxObject(result, 0);
42412 }
42413 return resultobj;
42414 fail:
42415 return NULL;
42416 }
42417
42418
42419 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42420 PyObject *resultobj = 0;
42421 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42422 wxMenu *arg2 = (wxMenu *) 0 ;
42423 void *argp1 = 0 ;
42424 int res1 = 0 ;
42425 void *argp2 = 0 ;
42426 int res2 = 0 ;
42427 PyObject * obj0 = 0 ;
42428 PyObject * obj1 = 0 ;
42429 char * kwnames[] = {
42430 (char *) "self",(char *) "menu", NULL
42431 };
42432
42433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42435 if (!SWIG_IsOK(res1)) {
42436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42437 }
42438 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42439 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42440 if (!SWIG_IsOK(res2)) {
42441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42442 }
42443 arg2 = reinterpret_cast< wxMenu * >(argp2);
42444 {
42445 PyThreadState* __tstate = wxPyBeginAllowThreads();
42446 (arg1)->SetMenu(arg2);
42447 wxPyEndAllowThreads(__tstate);
42448 if (PyErr_Occurred()) SWIG_fail;
42449 }
42450 resultobj = SWIG_Py_Void();
42451 return resultobj;
42452 fail:
42453 return NULL;
42454 }
42455
42456
42457 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42458 PyObject *resultobj = 0;
42459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42460 int arg2 ;
42461 void *argp1 = 0 ;
42462 int res1 = 0 ;
42463 int val2 ;
42464 int ecode2 = 0 ;
42465 PyObject * obj0 = 0 ;
42466 PyObject * obj1 = 0 ;
42467 char * kwnames[] = {
42468 (char *) "self",(char *) "id", NULL
42469 };
42470
42471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42473 if (!SWIG_IsOK(res1)) {
42474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42475 }
42476 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42477 ecode2 = SWIG_AsVal_int(obj1, &val2);
42478 if (!SWIG_IsOK(ecode2)) {
42479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42480 }
42481 arg2 = static_cast< int >(val2);
42482 {
42483 PyThreadState* __tstate = wxPyBeginAllowThreads();
42484 (arg1)->SetId(arg2);
42485 wxPyEndAllowThreads(__tstate);
42486 if (PyErr_Occurred()) SWIG_fail;
42487 }
42488 resultobj = SWIG_Py_Void();
42489 return resultobj;
42490 fail:
42491 return NULL;
42492 }
42493
42494
42495 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42496 PyObject *resultobj = 0;
42497 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42498 int result;
42499 void *argp1 = 0 ;
42500 int res1 = 0 ;
42501 PyObject *swig_obj[1] ;
42502
42503 if (!args) SWIG_fail;
42504 swig_obj[0] = args;
42505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42506 if (!SWIG_IsOK(res1)) {
42507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42508 }
42509 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42510 {
42511 PyThreadState* __tstate = wxPyBeginAllowThreads();
42512 result = (int)((wxMenuItem const *)arg1)->GetId();
42513 wxPyEndAllowThreads(__tstate);
42514 if (PyErr_Occurred()) SWIG_fail;
42515 }
42516 resultobj = SWIG_From_int(static_cast< int >(result));
42517 return resultobj;
42518 fail:
42519 return NULL;
42520 }
42521
42522
42523 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42524 PyObject *resultobj = 0;
42525 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42526 bool result;
42527 void *argp1 = 0 ;
42528 int res1 = 0 ;
42529 PyObject *swig_obj[1] ;
42530
42531 if (!args) SWIG_fail;
42532 swig_obj[0] = args;
42533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42534 if (!SWIG_IsOK(res1)) {
42535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42536 }
42537 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42538 {
42539 PyThreadState* __tstate = wxPyBeginAllowThreads();
42540 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42541 wxPyEndAllowThreads(__tstate);
42542 if (PyErr_Occurred()) SWIG_fail;
42543 }
42544 {
42545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42546 }
42547 return resultobj;
42548 fail:
42549 return NULL;
42550 }
42551
42552
42553 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42554 PyObject *resultobj = 0;
42555 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42556 wxString *arg2 = 0 ;
42557 void *argp1 = 0 ;
42558 int res1 = 0 ;
42559 bool temp2 = false ;
42560 PyObject * obj0 = 0 ;
42561 PyObject * obj1 = 0 ;
42562 char * kwnames[] = {
42563 (char *) "self",(char *) "str", NULL
42564 };
42565
42566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42568 if (!SWIG_IsOK(res1)) {
42569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42570 }
42571 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42572 {
42573 arg2 = wxString_in_helper(obj1);
42574 if (arg2 == NULL) SWIG_fail;
42575 temp2 = true;
42576 }
42577 {
42578 PyThreadState* __tstate = wxPyBeginAllowThreads();
42579 (arg1)->SetText((wxString const &)*arg2);
42580 wxPyEndAllowThreads(__tstate);
42581 if (PyErr_Occurred()) SWIG_fail;
42582 }
42583 resultobj = SWIG_Py_Void();
42584 {
42585 if (temp2)
42586 delete arg2;
42587 }
42588 return resultobj;
42589 fail:
42590 {
42591 if (temp2)
42592 delete arg2;
42593 }
42594 return NULL;
42595 }
42596
42597
42598 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42599 PyObject *resultobj = 0;
42600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42601 wxString result;
42602 void *argp1 = 0 ;
42603 int res1 = 0 ;
42604 PyObject *swig_obj[1] ;
42605
42606 if (!args) SWIG_fail;
42607 swig_obj[0] = args;
42608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42609 if (!SWIG_IsOK(res1)) {
42610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42611 }
42612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42613 {
42614 PyThreadState* __tstate = wxPyBeginAllowThreads();
42615 result = ((wxMenuItem const *)arg1)->GetLabel();
42616 wxPyEndAllowThreads(__tstate);
42617 if (PyErr_Occurred()) SWIG_fail;
42618 }
42619 {
42620 #if wxUSE_UNICODE
42621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42622 #else
42623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42624 #endif
42625 }
42626 return resultobj;
42627 fail:
42628 return NULL;
42629 }
42630
42631
42632 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42633 PyObject *resultobj = 0;
42634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42635 wxString *result = 0 ;
42636 void *argp1 = 0 ;
42637 int res1 = 0 ;
42638 PyObject *swig_obj[1] ;
42639
42640 if (!args) SWIG_fail;
42641 swig_obj[0] = args;
42642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42643 if (!SWIG_IsOK(res1)) {
42644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42645 }
42646 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42647 {
42648 PyThreadState* __tstate = wxPyBeginAllowThreads();
42649 {
42650 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42651 result = (wxString *) &_result_ref;
42652 }
42653 wxPyEndAllowThreads(__tstate);
42654 if (PyErr_Occurred()) SWIG_fail;
42655 }
42656 {
42657 #if wxUSE_UNICODE
42658 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42659 #else
42660 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42661 #endif
42662 }
42663 return resultobj;
42664 fail:
42665 return NULL;
42666 }
42667
42668
42669 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42670 PyObject *resultobj = 0;
42671 wxString *arg1 = 0 ;
42672 wxString result;
42673 bool temp1 = false ;
42674 PyObject * obj0 = 0 ;
42675 char * kwnames[] = {
42676 (char *) "text", NULL
42677 };
42678
42679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42680 {
42681 arg1 = wxString_in_helper(obj0);
42682 if (arg1 == NULL) SWIG_fail;
42683 temp1 = true;
42684 }
42685 {
42686 PyThreadState* __tstate = wxPyBeginAllowThreads();
42687 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42688 wxPyEndAllowThreads(__tstate);
42689 if (PyErr_Occurred()) SWIG_fail;
42690 }
42691 {
42692 #if wxUSE_UNICODE
42693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42694 #else
42695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42696 #endif
42697 }
42698 {
42699 if (temp1)
42700 delete arg1;
42701 }
42702 return resultobj;
42703 fail:
42704 {
42705 if (temp1)
42706 delete arg1;
42707 }
42708 return NULL;
42709 }
42710
42711
42712 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42713 PyObject *resultobj = 0;
42714 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42715 wxItemKind result;
42716 void *argp1 = 0 ;
42717 int res1 = 0 ;
42718 PyObject *swig_obj[1] ;
42719
42720 if (!args) SWIG_fail;
42721 swig_obj[0] = args;
42722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42723 if (!SWIG_IsOK(res1)) {
42724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42725 }
42726 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42727 {
42728 PyThreadState* __tstate = wxPyBeginAllowThreads();
42729 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42730 wxPyEndAllowThreads(__tstate);
42731 if (PyErr_Occurred()) SWIG_fail;
42732 }
42733 resultobj = SWIG_From_int(static_cast< int >(result));
42734 return resultobj;
42735 fail:
42736 return NULL;
42737 }
42738
42739
42740 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42741 PyObject *resultobj = 0;
42742 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42743 wxItemKind arg2 ;
42744 void *argp1 = 0 ;
42745 int res1 = 0 ;
42746 int val2 ;
42747 int ecode2 = 0 ;
42748 PyObject * obj0 = 0 ;
42749 PyObject * obj1 = 0 ;
42750 char * kwnames[] = {
42751 (char *) "self",(char *) "kind", NULL
42752 };
42753
42754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42756 if (!SWIG_IsOK(res1)) {
42757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42758 }
42759 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42760 ecode2 = SWIG_AsVal_int(obj1, &val2);
42761 if (!SWIG_IsOK(ecode2)) {
42762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42763 }
42764 arg2 = static_cast< wxItemKind >(val2);
42765 {
42766 PyThreadState* __tstate = wxPyBeginAllowThreads();
42767 (arg1)->SetKind(arg2);
42768 wxPyEndAllowThreads(__tstate);
42769 if (PyErr_Occurred()) SWIG_fail;
42770 }
42771 resultobj = SWIG_Py_Void();
42772 return resultobj;
42773 fail:
42774 return NULL;
42775 }
42776
42777
42778 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42779 PyObject *resultobj = 0;
42780 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42781 bool arg2 ;
42782 void *argp1 = 0 ;
42783 int res1 = 0 ;
42784 bool val2 ;
42785 int ecode2 = 0 ;
42786 PyObject * obj0 = 0 ;
42787 PyObject * obj1 = 0 ;
42788 char * kwnames[] = {
42789 (char *) "self",(char *) "checkable", NULL
42790 };
42791
42792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42794 if (!SWIG_IsOK(res1)) {
42795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42796 }
42797 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42798 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42799 if (!SWIG_IsOK(ecode2)) {
42800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42801 }
42802 arg2 = static_cast< bool >(val2);
42803 {
42804 PyThreadState* __tstate = wxPyBeginAllowThreads();
42805 (arg1)->SetCheckable(arg2);
42806 wxPyEndAllowThreads(__tstate);
42807 if (PyErr_Occurred()) SWIG_fail;
42808 }
42809 resultobj = SWIG_Py_Void();
42810 return resultobj;
42811 fail:
42812 return NULL;
42813 }
42814
42815
42816 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42817 PyObject *resultobj = 0;
42818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42819 bool result;
42820 void *argp1 = 0 ;
42821 int res1 = 0 ;
42822 PyObject *swig_obj[1] ;
42823
42824 if (!args) SWIG_fail;
42825 swig_obj[0] = args;
42826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42827 if (!SWIG_IsOK(res1)) {
42828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42829 }
42830 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42831 {
42832 PyThreadState* __tstate = wxPyBeginAllowThreads();
42833 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42834 wxPyEndAllowThreads(__tstate);
42835 if (PyErr_Occurred()) SWIG_fail;
42836 }
42837 {
42838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42839 }
42840 return resultobj;
42841 fail:
42842 return NULL;
42843 }
42844
42845
42846 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42847 PyObject *resultobj = 0;
42848 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42849 bool result;
42850 void *argp1 = 0 ;
42851 int res1 = 0 ;
42852 PyObject *swig_obj[1] ;
42853
42854 if (!args) SWIG_fail;
42855 swig_obj[0] = args;
42856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42857 if (!SWIG_IsOK(res1)) {
42858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42859 }
42860 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42861 {
42862 PyThreadState* __tstate = wxPyBeginAllowThreads();
42863 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42864 wxPyEndAllowThreads(__tstate);
42865 if (PyErr_Occurred()) SWIG_fail;
42866 }
42867 {
42868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42869 }
42870 return resultobj;
42871 fail:
42872 return NULL;
42873 }
42874
42875
42876 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42877 PyObject *resultobj = 0;
42878 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42879 wxMenu *arg2 = (wxMenu *) 0 ;
42880 void *argp1 = 0 ;
42881 int res1 = 0 ;
42882 void *argp2 = 0 ;
42883 int res2 = 0 ;
42884 PyObject * obj0 = 0 ;
42885 PyObject * obj1 = 0 ;
42886 char * kwnames[] = {
42887 (char *) "self",(char *) "menu", NULL
42888 };
42889
42890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42892 if (!SWIG_IsOK(res1)) {
42893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42894 }
42895 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42897 if (!SWIG_IsOK(res2)) {
42898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42899 }
42900 arg2 = reinterpret_cast< wxMenu * >(argp2);
42901 {
42902 PyThreadState* __tstate = wxPyBeginAllowThreads();
42903 (arg1)->SetSubMenu(arg2);
42904 wxPyEndAllowThreads(__tstate);
42905 if (PyErr_Occurred()) SWIG_fail;
42906 }
42907 resultobj = SWIG_Py_Void();
42908 return resultobj;
42909 fail:
42910 return NULL;
42911 }
42912
42913
42914 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42915 PyObject *resultobj = 0;
42916 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42917 wxMenu *result = 0 ;
42918 void *argp1 = 0 ;
42919 int res1 = 0 ;
42920 PyObject *swig_obj[1] ;
42921
42922 if (!args) SWIG_fail;
42923 swig_obj[0] = args;
42924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42925 if (!SWIG_IsOK(res1)) {
42926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42927 }
42928 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42929 {
42930 PyThreadState* __tstate = wxPyBeginAllowThreads();
42931 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42932 wxPyEndAllowThreads(__tstate);
42933 if (PyErr_Occurred()) SWIG_fail;
42934 }
42935 {
42936 resultobj = wxPyMake_wxObject(result, 0);
42937 }
42938 return resultobj;
42939 fail:
42940 return NULL;
42941 }
42942
42943
42944 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42945 PyObject *resultobj = 0;
42946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42947 bool arg2 = (bool) true ;
42948 void *argp1 = 0 ;
42949 int res1 = 0 ;
42950 bool val2 ;
42951 int ecode2 = 0 ;
42952 PyObject * obj0 = 0 ;
42953 PyObject * obj1 = 0 ;
42954 char * kwnames[] = {
42955 (char *) "self",(char *) "enable", NULL
42956 };
42957
42958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42960 if (!SWIG_IsOK(res1)) {
42961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42962 }
42963 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42964 if (obj1) {
42965 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42966 if (!SWIG_IsOK(ecode2)) {
42967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42968 }
42969 arg2 = static_cast< bool >(val2);
42970 }
42971 {
42972 PyThreadState* __tstate = wxPyBeginAllowThreads();
42973 (arg1)->Enable(arg2);
42974 wxPyEndAllowThreads(__tstate);
42975 if (PyErr_Occurred()) SWIG_fail;
42976 }
42977 resultobj = SWIG_Py_Void();
42978 return resultobj;
42979 fail:
42980 return NULL;
42981 }
42982
42983
42984 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42985 PyObject *resultobj = 0;
42986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42987 bool result;
42988 void *argp1 = 0 ;
42989 int res1 = 0 ;
42990 PyObject *swig_obj[1] ;
42991
42992 if (!args) SWIG_fail;
42993 swig_obj[0] = args;
42994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42995 if (!SWIG_IsOK(res1)) {
42996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42997 }
42998 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42999 {
43000 PyThreadState* __tstate = wxPyBeginAllowThreads();
43001 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43002 wxPyEndAllowThreads(__tstate);
43003 if (PyErr_Occurred()) SWIG_fail;
43004 }
43005 {
43006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43007 }
43008 return resultobj;
43009 fail:
43010 return NULL;
43011 }
43012
43013
43014 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43015 PyObject *resultobj = 0;
43016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43017 bool arg2 = (bool) true ;
43018 void *argp1 = 0 ;
43019 int res1 = 0 ;
43020 bool val2 ;
43021 int ecode2 = 0 ;
43022 PyObject * obj0 = 0 ;
43023 PyObject * obj1 = 0 ;
43024 char * kwnames[] = {
43025 (char *) "self",(char *) "check", NULL
43026 };
43027
43028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43030 if (!SWIG_IsOK(res1)) {
43031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43032 }
43033 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43034 if (obj1) {
43035 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43036 if (!SWIG_IsOK(ecode2)) {
43037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43038 }
43039 arg2 = static_cast< bool >(val2);
43040 }
43041 {
43042 PyThreadState* __tstate = wxPyBeginAllowThreads();
43043 (arg1)->Check(arg2);
43044 wxPyEndAllowThreads(__tstate);
43045 if (PyErr_Occurred()) SWIG_fail;
43046 }
43047 resultobj = SWIG_Py_Void();
43048 return resultobj;
43049 fail:
43050 return NULL;
43051 }
43052
43053
43054 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43055 PyObject *resultobj = 0;
43056 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43057 bool result;
43058 void *argp1 = 0 ;
43059 int res1 = 0 ;
43060 PyObject *swig_obj[1] ;
43061
43062 if (!args) SWIG_fail;
43063 swig_obj[0] = args;
43064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43065 if (!SWIG_IsOK(res1)) {
43066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43067 }
43068 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43069 {
43070 PyThreadState* __tstate = wxPyBeginAllowThreads();
43071 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43072 wxPyEndAllowThreads(__tstate);
43073 if (PyErr_Occurred()) SWIG_fail;
43074 }
43075 {
43076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43077 }
43078 return resultobj;
43079 fail:
43080 return NULL;
43081 }
43082
43083
43084 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43085 PyObject *resultobj = 0;
43086 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43087 void *argp1 = 0 ;
43088 int res1 = 0 ;
43089 PyObject *swig_obj[1] ;
43090
43091 if (!args) SWIG_fail;
43092 swig_obj[0] = args;
43093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43094 if (!SWIG_IsOK(res1)) {
43095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43096 }
43097 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43098 {
43099 PyThreadState* __tstate = wxPyBeginAllowThreads();
43100 (arg1)->Toggle();
43101 wxPyEndAllowThreads(__tstate);
43102 if (PyErr_Occurred()) SWIG_fail;
43103 }
43104 resultobj = SWIG_Py_Void();
43105 return resultobj;
43106 fail:
43107 return NULL;
43108 }
43109
43110
43111 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43112 PyObject *resultobj = 0;
43113 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43114 wxString *arg2 = 0 ;
43115 void *argp1 = 0 ;
43116 int res1 = 0 ;
43117 bool temp2 = false ;
43118 PyObject * obj0 = 0 ;
43119 PyObject * obj1 = 0 ;
43120 char * kwnames[] = {
43121 (char *) "self",(char *) "str", NULL
43122 };
43123
43124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43126 if (!SWIG_IsOK(res1)) {
43127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43128 }
43129 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43130 {
43131 arg2 = wxString_in_helper(obj1);
43132 if (arg2 == NULL) SWIG_fail;
43133 temp2 = true;
43134 }
43135 {
43136 PyThreadState* __tstate = wxPyBeginAllowThreads();
43137 (arg1)->SetHelp((wxString const &)*arg2);
43138 wxPyEndAllowThreads(__tstate);
43139 if (PyErr_Occurred()) SWIG_fail;
43140 }
43141 resultobj = SWIG_Py_Void();
43142 {
43143 if (temp2)
43144 delete arg2;
43145 }
43146 return resultobj;
43147 fail:
43148 {
43149 if (temp2)
43150 delete arg2;
43151 }
43152 return NULL;
43153 }
43154
43155
43156 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43157 PyObject *resultobj = 0;
43158 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43159 wxString *result = 0 ;
43160 void *argp1 = 0 ;
43161 int res1 = 0 ;
43162 PyObject *swig_obj[1] ;
43163
43164 if (!args) SWIG_fail;
43165 swig_obj[0] = args;
43166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43167 if (!SWIG_IsOK(res1)) {
43168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43169 }
43170 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43171 {
43172 PyThreadState* __tstate = wxPyBeginAllowThreads();
43173 {
43174 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43175 result = (wxString *) &_result_ref;
43176 }
43177 wxPyEndAllowThreads(__tstate);
43178 if (PyErr_Occurred()) SWIG_fail;
43179 }
43180 {
43181 #if wxUSE_UNICODE
43182 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43183 #else
43184 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43185 #endif
43186 }
43187 return resultobj;
43188 fail:
43189 return NULL;
43190 }
43191
43192
43193 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43194 PyObject *resultobj = 0;
43195 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43196 wxAcceleratorEntry *result = 0 ;
43197 void *argp1 = 0 ;
43198 int res1 = 0 ;
43199 PyObject *swig_obj[1] ;
43200
43201 if (!args) SWIG_fail;
43202 swig_obj[0] = args;
43203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43204 if (!SWIG_IsOK(res1)) {
43205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43206 }
43207 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43215 return resultobj;
43216 fail:
43217 return NULL;
43218 }
43219
43220
43221 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43222 PyObject *resultobj = 0;
43223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43224 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43225 void *argp1 = 0 ;
43226 int res1 = 0 ;
43227 void *argp2 = 0 ;
43228 int res2 = 0 ;
43229 PyObject * obj0 = 0 ;
43230 PyObject * obj1 = 0 ;
43231 char * kwnames[] = {
43232 (char *) "self",(char *) "accel", NULL
43233 };
43234
43235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43237 if (!SWIG_IsOK(res1)) {
43238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43239 }
43240 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43241 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43242 if (!SWIG_IsOK(res2)) {
43243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43244 }
43245 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43246 {
43247 PyThreadState* __tstate = wxPyBeginAllowThreads();
43248 (arg1)->SetAccel(arg2);
43249 wxPyEndAllowThreads(__tstate);
43250 if (PyErr_Occurred()) SWIG_fail;
43251 }
43252 resultobj = SWIG_Py_Void();
43253 return resultobj;
43254 fail:
43255 return NULL;
43256 }
43257
43258
43259 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43260 PyObject *resultobj = 0;
43261 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43262 wxBitmap *arg2 = 0 ;
43263 void *argp1 = 0 ;
43264 int res1 = 0 ;
43265 void *argp2 = 0 ;
43266 int res2 = 0 ;
43267 PyObject * obj0 = 0 ;
43268 PyObject * obj1 = 0 ;
43269 char * kwnames[] = {
43270 (char *) "self",(char *) "bitmap", NULL
43271 };
43272
43273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43275 if (!SWIG_IsOK(res1)) {
43276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43277 }
43278 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43279 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43280 if (!SWIG_IsOK(res2)) {
43281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43282 }
43283 if (!argp2) {
43284 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43285 }
43286 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43287 {
43288 PyThreadState* __tstate = wxPyBeginAllowThreads();
43289 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43290 wxPyEndAllowThreads(__tstate);
43291 if (PyErr_Occurred()) SWIG_fail;
43292 }
43293 resultobj = SWIG_Py_Void();
43294 return resultobj;
43295 fail:
43296 return NULL;
43297 }
43298
43299
43300 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43301 PyObject *resultobj = 0;
43302 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43303 wxBitmap *result = 0 ;
43304 void *argp1 = 0 ;
43305 int res1 = 0 ;
43306 PyObject *swig_obj[1] ;
43307
43308 if (!args) SWIG_fail;
43309 swig_obj[0] = args;
43310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43311 if (!SWIG_IsOK(res1)) {
43312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43313 }
43314 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43315 {
43316 PyThreadState* __tstate = wxPyBeginAllowThreads();
43317 {
43318 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43319 result = (wxBitmap *) &_result_ref;
43320 }
43321 wxPyEndAllowThreads(__tstate);
43322 if (PyErr_Occurred()) SWIG_fail;
43323 }
43324 {
43325 wxBitmap* resultptr = new wxBitmap(*result);
43326 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43327 }
43328 return resultobj;
43329 fail:
43330 return NULL;
43331 }
43332
43333
43334 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43335 PyObject *resultobj = 0;
43336 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43337 wxFont *arg2 = 0 ;
43338 void *argp1 = 0 ;
43339 int res1 = 0 ;
43340 void *argp2 = 0 ;
43341 int res2 = 0 ;
43342 PyObject * obj0 = 0 ;
43343 PyObject * obj1 = 0 ;
43344 char * kwnames[] = {
43345 (char *) "self",(char *) "font", NULL
43346 };
43347
43348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43350 if (!SWIG_IsOK(res1)) {
43351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43352 }
43353 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43354 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43355 if (!SWIG_IsOK(res2)) {
43356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43357 }
43358 if (!argp2) {
43359 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43360 }
43361 arg2 = reinterpret_cast< wxFont * >(argp2);
43362 {
43363 PyThreadState* __tstate = wxPyBeginAllowThreads();
43364 (arg1)->SetFont((wxFont const &)*arg2);
43365 wxPyEndAllowThreads(__tstate);
43366 if (PyErr_Occurred()) SWIG_fail;
43367 }
43368 resultobj = SWIG_Py_Void();
43369 return resultobj;
43370 fail:
43371 return NULL;
43372 }
43373
43374
43375 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43376 PyObject *resultobj = 0;
43377 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43378 wxFont result;
43379 void *argp1 = 0 ;
43380 int res1 = 0 ;
43381 PyObject *swig_obj[1] ;
43382
43383 if (!args) SWIG_fail;
43384 swig_obj[0] = args;
43385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43386 if (!SWIG_IsOK(res1)) {
43387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43388 }
43389 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43390 {
43391 PyThreadState* __tstate = wxPyBeginAllowThreads();
43392 result = (arg1)->GetFont();
43393 wxPyEndAllowThreads(__tstate);
43394 if (PyErr_Occurred()) SWIG_fail;
43395 }
43396 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43397 return resultobj;
43398 fail:
43399 return NULL;
43400 }
43401
43402
43403 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43404 PyObject *resultobj = 0;
43405 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43406 wxColour *arg2 = 0 ;
43407 void *argp1 = 0 ;
43408 int res1 = 0 ;
43409 wxColour temp2 ;
43410 PyObject * obj0 = 0 ;
43411 PyObject * obj1 = 0 ;
43412 char * kwnames[] = {
43413 (char *) "self",(char *) "colText", NULL
43414 };
43415
43416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43418 if (!SWIG_IsOK(res1)) {
43419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43420 }
43421 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43422 {
43423 arg2 = &temp2;
43424 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43425 }
43426 {
43427 PyThreadState* __tstate = wxPyBeginAllowThreads();
43428 (arg1)->SetTextColour((wxColour const &)*arg2);
43429 wxPyEndAllowThreads(__tstate);
43430 if (PyErr_Occurred()) SWIG_fail;
43431 }
43432 resultobj = SWIG_Py_Void();
43433 return resultobj;
43434 fail:
43435 return NULL;
43436 }
43437
43438
43439 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43440 PyObject *resultobj = 0;
43441 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43442 wxColour result;
43443 void *argp1 = 0 ;
43444 int res1 = 0 ;
43445 PyObject *swig_obj[1] ;
43446
43447 if (!args) SWIG_fail;
43448 swig_obj[0] = args;
43449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43450 if (!SWIG_IsOK(res1)) {
43451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43452 }
43453 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43454 {
43455 PyThreadState* __tstate = wxPyBeginAllowThreads();
43456 result = (arg1)->GetTextColour();
43457 wxPyEndAllowThreads(__tstate);
43458 if (PyErr_Occurred()) SWIG_fail;
43459 }
43460 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43461 return resultobj;
43462 fail:
43463 return NULL;
43464 }
43465
43466
43467 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43468 PyObject *resultobj = 0;
43469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43470 wxColour *arg2 = 0 ;
43471 void *argp1 = 0 ;
43472 int res1 = 0 ;
43473 wxColour temp2 ;
43474 PyObject * obj0 = 0 ;
43475 PyObject * obj1 = 0 ;
43476 char * kwnames[] = {
43477 (char *) "self",(char *) "colBack", NULL
43478 };
43479
43480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43482 if (!SWIG_IsOK(res1)) {
43483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43484 }
43485 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43486 {
43487 arg2 = &temp2;
43488 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43489 }
43490 {
43491 PyThreadState* __tstate = wxPyBeginAllowThreads();
43492 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43493 wxPyEndAllowThreads(__tstate);
43494 if (PyErr_Occurred()) SWIG_fail;
43495 }
43496 resultobj = SWIG_Py_Void();
43497 return resultobj;
43498 fail:
43499 return NULL;
43500 }
43501
43502
43503 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43504 PyObject *resultobj = 0;
43505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43506 wxColour result;
43507 void *argp1 = 0 ;
43508 int res1 = 0 ;
43509 PyObject *swig_obj[1] ;
43510
43511 if (!args) SWIG_fail;
43512 swig_obj[0] = args;
43513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43514 if (!SWIG_IsOK(res1)) {
43515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43516 }
43517 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43518 {
43519 PyThreadState* __tstate = wxPyBeginAllowThreads();
43520 result = (arg1)->GetBackgroundColour();
43521 wxPyEndAllowThreads(__tstate);
43522 if (PyErr_Occurred()) SWIG_fail;
43523 }
43524 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43525 return resultobj;
43526 fail:
43527 return NULL;
43528 }
43529
43530
43531 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43532 PyObject *resultobj = 0;
43533 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43534 wxBitmap *arg2 = 0 ;
43535 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43536 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43537 void *argp1 = 0 ;
43538 int res1 = 0 ;
43539 void *argp2 = 0 ;
43540 int res2 = 0 ;
43541 void *argp3 = 0 ;
43542 int res3 = 0 ;
43543 PyObject * obj0 = 0 ;
43544 PyObject * obj1 = 0 ;
43545 PyObject * obj2 = 0 ;
43546 char * kwnames[] = {
43547 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43548 };
43549
43550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43552 if (!SWIG_IsOK(res1)) {
43553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43554 }
43555 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43556 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43557 if (!SWIG_IsOK(res2)) {
43558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43559 }
43560 if (!argp2) {
43561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43562 }
43563 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43564 if (obj2) {
43565 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43566 if (!SWIG_IsOK(res3)) {
43567 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43568 }
43569 if (!argp3) {
43570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43571 }
43572 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43573 }
43574 {
43575 PyThreadState* __tstate = wxPyBeginAllowThreads();
43576 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43577 wxPyEndAllowThreads(__tstate);
43578 if (PyErr_Occurred()) SWIG_fail;
43579 }
43580 resultobj = SWIG_Py_Void();
43581 return resultobj;
43582 fail:
43583 return NULL;
43584 }
43585
43586
43587 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43588 PyObject *resultobj = 0;
43589 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43590 wxBitmap *arg2 = 0 ;
43591 void *argp1 = 0 ;
43592 int res1 = 0 ;
43593 void *argp2 = 0 ;
43594 int res2 = 0 ;
43595 PyObject * obj0 = 0 ;
43596 PyObject * obj1 = 0 ;
43597 char * kwnames[] = {
43598 (char *) "self",(char *) "bmpDisabled", NULL
43599 };
43600
43601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43603 if (!SWIG_IsOK(res1)) {
43604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43605 }
43606 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43607 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43608 if (!SWIG_IsOK(res2)) {
43609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43610 }
43611 if (!argp2) {
43612 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43613 }
43614 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43615 {
43616 PyThreadState* __tstate = wxPyBeginAllowThreads();
43617 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43618 wxPyEndAllowThreads(__tstate);
43619 if (PyErr_Occurred()) SWIG_fail;
43620 }
43621 resultobj = SWIG_Py_Void();
43622 return resultobj;
43623 fail:
43624 return NULL;
43625 }
43626
43627
43628 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43629 PyObject *resultobj = 0;
43630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43631 wxBitmap *result = 0 ;
43632 void *argp1 = 0 ;
43633 int res1 = 0 ;
43634 PyObject *swig_obj[1] ;
43635
43636 if (!args) SWIG_fail;
43637 swig_obj[0] = args;
43638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43639 if (!SWIG_IsOK(res1)) {
43640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43641 }
43642 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43643 {
43644 PyThreadState* __tstate = wxPyBeginAllowThreads();
43645 {
43646 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43647 result = (wxBitmap *) &_result_ref;
43648 }
43649 wxPyEndAllowThreads(__tstate);
43650 if (PyErr_Occurred()) SWIG_fail;
43651 }
43652 {
43653 wxBitmap* resultptr = new wxBitmap(*result);
43654 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43655 }
43656 return resultobj;
43657 fail:
43658 return NULL;
43659 }
43660
43661
43662 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43663 PyObject *resultobj = 0;
43664 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43665 int arg2 ;
43666 void *argp1 = 0 ;
43667 int res1 = 0 ;
43668 int val2 ;
43669 int ecode2 = 0 ;
43670 PyObject * obj0 = 0 ;
43671 PyObject * obj1 = 0 ;
43672 char * kwnames[] = {
43673 (char *) "self",(char *) "nWidth", NULL
43674 };
43675
43676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43678 if (!SWIG_IsOK(res1)) {
43679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43680 }
43681 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43682 ecode2 = SWIG_AsVal_int(obj1, &val2);
43683 if (!SWIG_IsOK(ecode2)) {
43684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43685 }
43686 arg2 = static_cast< int >(val2);
43687 {
43688 PyThreadState* __tstate = wxPyBeginAllowThreads();
43689 (arg1)->SetMarginWidth(arg2);
43690 wxPyEndAllowThreads(__tstate);
43691 if (PyErr_Occurred()) SWIG_fail;
43692 }
43693 resultobj = SWIG_Py_Void();
43694 return resultobj;
43695 fail:
43696 return NULL;
43697 }
43698
43699
43700 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43701 PyObject *resultobj = 0;
43702 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43703 int result;
43704 void *argp1 = 0 ;
43705 int res1 = 0 ;
43706 PyObject *swig_obj[1] ;
43707
43708 if (!args) SWIG_fail;
43709 swig_obj[0] = args;
43710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43711 if (!SWIG_IsOK(res1)) {
43712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43713 }
43714 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43715 {
43716 PyThreadState* __tstate = wxPyBeginAllowThreads();
43717 result = (int)(arg1)->GetMarginWidth();
43718 wxPyEndAllowThreads(__tstate);
43719 if (PyErr_Occurred()) SWIG_fail;
43720 }
43721 resultobj = SWIG_From_int(static_cast< int >(result));
43722 return resultobj;
43723 fail:
43724 return NULL;
43725 }
43726
43727
43728 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43729 PyObject *resultobj = 0;
43730 int result;
43731
43732 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43733 {
43734 PyThreadState* __tstate = wxPyBeginAllowThreads();
43735 result = (int)wxMenuItem::GetDefaultMarginWidth();
43736 wxPyEndAllowThreads(__tstate);
43737 if (PyErr_Occurred()) SWIG_fail;
43738 }
43739 resultobj = SWIG_From_int(static_cast< int >(result));
43740 return resultobj;
43741 fail:
43742 return NULL;
43743 }
43744
43745
43746 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43747 PyObject *resultobj = 0;
43748 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43749 bool result;
43750 void *argp1 = 0 ;
43751 int res1 = 0 ;
43752 PyObject *swig_obj[1] ;
43753
43754 if (!args) SWIG_fail;
43755 swig_obj[0] = args;
43756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43757 if (!SWIG_IsOK(res1)) {
43758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43759 }
43760 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43761 {
43762 PyThreadState* __tstate = wxPyBeginAllowThreads();
43763 result = (bool)(arg1)->IsOwnerDrawn();
43764 wxPyEndAllowThreads(__tstate);
43765 if (PyErr_Occurred()) SWIG_fail;
43766 }
43767 {
43768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43769 }
43770 return resultobj;
43771 fail:
43772 return NULL;
43773 }
43774
43775
43776 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43777 PyObject *resultobj = 0;
43778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43779 bool arg2 = (bool) true ;
43780 void *argp1 = 0 ;
43781 int res1 = 0 ;
43782 bool val2 ;
43783 int ecode2 = 0 ;
43784 PyObject * obj0 = 0 ;
43785 PyObject * obj1 = 0 ;
43786 char * kwnames[] = {
43787 (char *) "self",(char *) "ownerDrawn", NULL
43788 };
43789
43790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43792 if (!SWIG_IsOK(res1)) {
43793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43794 }
43795 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43796 if (obj1) {
43797 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43798 if (!SWIG_IsOK(ecode2)) {
43799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43800 }
43801 arg2 = static_cast< bool >(val2);
43802 }
43803 {
43804 PyThreadState* __tstate = wxPyBeginAllowThreads();
43805 (arg1)->SetOwnerDrawn(arg2);
43806 wxPyEndAllowThreads(__tstate);
43807 if (PyErr_Occurred()) SWIG_fail;
43808 }
43809 resultobj = SWIG_Py_Void();
43810 return resultobj;
43811 fail:
43812 return NULL;
43813 }
43814
43815
43816 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43817 PyObject *resultobj = 0;
43818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43819 void *argp1 = 0 ;
43820 int res1 = 0 ;
43821 PyObject *swig_obj[1] ;
43822
43823 if (!args) SWIG_fail;
43824 swig_obj[0] = args;
43825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43826 if (!SWIG_IsOK(res1)) {
43827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43828 }
43829 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43830 {
43831 PyThreadState* __tstate = wxPyBeginAllowThreads();
43832 (arg1)->ResetOwnerDrawn();
43833 wxPyEndAllowThreads(__tstate);
43834 if (PyErr_Occurred()) SWIG_fail;
43835 }
43836 resultobj = SWIG_Py_Void();
43837 return resultobj;
43838 fail:
43839 return NULL;
43840 }
43841
43842
43843 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43844 PyObject *obj;
43845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43846 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43847 return SWIG_Py_Void();
43848 }
43849
43850 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43851 return SWIG_Python_InitShadowInstance(args);
43852 }
43853
43854 SWIGINTERN int ControlNameStr_set(PyObject *) {
43855 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43856 return 1;
43857 }
43858
43859
43860 SWIGINTERN PyObject *ControlNameStr_get(void) {
43861 PyObject *pyobj = 0;
43862
43863 {
43864 #if wxUSE_UNICODE
43865 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43866 #else
43867 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43868 #endif
43869 }
43870 return pyobj;
43871 }
43872
43873
43874 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43875 PyObject *resultobj = 0;
43876 wxWindow *arg1 = (wxWindow *) 0 ;
43877 int arg2 = (int) -1 ;
43878 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43879 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43880 wxSize const &arg4_defvalue = wxDefaultSize ;
43881 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43882 long arg5 = (long) 0 ;
43883 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43884 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43885 wxString const &arg7_defvalue = wxPyControlNameStr ;
43886 wxString *arg7 = (wxString *) &arg7_defvalue ;
43887 wxControl *result = 0 ;
43888 void *argp1 = 0 ;
43889 int res1 = 0 ;
43890 int val2 ;
43891 int ecode2 = 0 ;
43892 wxPoint temp3 ;
43893 wxSize temp4 ;
43894 long val5 ;
43895 int ecode5 = 0 ;
43896 void *argp6 = 0 ;
43897 int res6 = 0 ;
43898 bool temp7 = false ;
43899 PyObject * obj0 = 0 ;
43900 PyObject * obj1 = 0 ;
43901 PyObject * obj2 = 0 ;
43902 PyObject * obj3 = 0 ;
43903 PyObject * obj4 = 0 ;
43904 PyObject * obj5 = 0 ;
43905 PyObject * obj6 = 0 ;
43906 char * kwnames[] = {
43907 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43908 };
43909
43910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43912 if (!SWIG_IsOK(res1)) {
43913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43914 }
43915 arg1 = reinterpret_cast< wxWindow * >(argp1);
43916 if (obj1) {
43917 ecode2 = SWIG_AsVal_int(obj1, &val2);
43918 if (!SWIG_IsOK(ecode2)) {
43919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43920 }
43921 arg2 = static_cast< int >(val2);
43922 }
43923 if (obj2) {
43924 {
43925 arg3 = &temp3;
43926 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43927 }
43928 }
43929 if (obj3) {
43930 {
43931 arg4 = &temp4;
43932 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43933 }
43934 }
43935 if (obj4) {
43936 ecode5 = SWIG_AsVal_long(obj4, &val5);
43937 if (!SWIG_IsOK(ecode5)) {
43938 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43939 }
43940 arg5 = static_cast< long >(val5);
43941 }
43942 if (obj5) {
43943 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43944 if (!SWIG_IsOK(res6)) {
43945 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43946 }
43947 if (!argp6) {
43948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43949 }
43950 arg6 = reinterpret_cast< wxValidator * >(argp6);
43951 }
43952 if (obj6) {
43953 {
43954 arg7 = wxString_in_helper(obj6);
43955 if (arg7 == NULL) SWIG_fail;
43956 temp7 = true;
43957 }
43958 }
43959 {
43960 if (!wxPyCheckForApp()) SWIG_fail;
43961 PyThreadState* __tstate = wxPyBeginAllowThreads();
43962 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43963 wxPyEndAllowThreads(__tstate);
43964 if (PyErr_Occurred()) SWIG_fail;
43965 }
43966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43967 {
43968 if (temp7)
43969 delete arg7;
43970 }
43971 return resultobj;
43972 fail:
43973 {
43974 if (temp7)
43975 delete arg7;
43976 }
43977 return NULL;
43978 }
43979
43980
43981 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43982 PyObject *resultobj = 0;
43983 wxControl *result = 0 ;
43984
43985 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43986 {
43987 if (!wxPyCheckForApp()) SWIG_fail;
43988 PyThreadState* __tstate = wxPyBeginAllowThreads();
43989 result = (wxControl *)new wxControl();
43990 wxPyEndAllowThreads(__tstate);
43991 if (PyErr_Occurred()) SWIG_fail;
43992 }
43993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43994 return resultobj;
43995 fail:
43996 return NULL;
43997 }
43998
43999
44000 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44001 PyObject *resultobj = 0;
44002 wxControl *arg1 = (wxControl *) 0 ;
44003 wxWindow *arg2 = (wxWindow *) 0 ;
44004 int arg3 = (int) -1 ;
44005 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44006 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44007 wxSize const &arg5_defvalue = wxDefaultSize ;
44008 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44009 long arg6 = (long) 0 ;
44010 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44011 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44012 wxString const &arg8_defvalue = wxPyControlNameStr ;
44013 wxString *arg8 = (wxString *) &arg8_defvalue ;
44014 bool result;
44015 void *argp1 = 0 ;
44016 int res1 = 0 ;
44017 void *argp2 = 0 ;
44018 int res2 = 0 ;
44019 int val3 ;
44020 int ecode3 = 0 ;
44021 wxPoint temp4 ;
44022 wxSize temp5 ;
44023 long val6 ;
44024 int ecode6 = 0 ;
44025 void *argp7 = 0 ;
44026 int res7 = 0 ;
44027 bool temp8 = false ;
44028 PyObject * obj0 = 0 ;
44029 PyObject * obj1 = 0 ;
44030 PyObject * obj2 = 0 ;
44031 PyObject * obj3 = 0 ;
44032 PyObject * obj4 = 0 ;
44033 PyObject * obj5 = 0 ;
44034 PyObject * obj6 = 0 ;
44035 PyObject * obj7 = 0 ;
44036 char * kwnames[] = {
44037 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44038 };
44039
44040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44042 if (!SWIG_IsOK(res1)) {
44043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44044 }
44045 arg1 = reinterpret_cast< wxControl * >(argp1);
44046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44047 if (!SWIG_IsOK(res2)) {
44048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44049 }
44050 arg2 = reinterpret_cast< wxWindow * >(argp2);
44051 if (obj2) {
44052 ecode3 = SWIG_AsVal_int(obj2, &val3);
44053 if (!SWIG_IsOK(ecode3)) {
44054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44055 }
44056 arg3 = static_cast< int >(val3);
44057 }
44058 if (obj3) {
44059 {
44060 arg4 = &temp4;
44061 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44062 }
44063 }
44064 if (obj4) {
44065 {
44066 arg5 = &temp5;
44067 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44068 }
44069 }
44070 if (obj5) {
44071 ecode6 = SWIG_AsVal_long(obj5, &val6);
44072 if (!SWIG_IsOK(ecode6)) {
44073 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44074 }
44075 arg6 = static_cast< long >(val6);
44076 }
44077 if (obj6) {
44078 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44079 if (!SWIG_IsOK(res7)) {
44080 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44081 }
44082 if (!argp7) {
44083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44084 }
44085 arg7 = reinterpret_cast< wxValidator * >(argp7);
44086 }
44087 if (obj7) {
44088 {
44089 arg8 = wxString_in_helper(obj7);
44090 if (arg8 == NULL) SWIG_fail;
44091 temp8 = true;
44092 }
44093 }
44094 {
44095 PyThreadState* __tstate = wxPyBeginAllowThreads();
44096 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44097 wxPyEndAllowThreads(__tstate);
44098 if (PyErr_Occurred()) SWIG_fail;
44099 }
44100 {
44101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44102 }
44103 {
44104 if (temp8)
44105 delete arg8;
44106 }
44107 return resultobj;
44108 fail:
44109 {
44110 if (temp8)
44111 delete arg8;
44112 }
44113 return NULL;
44114 }
44115
44116
44117 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44118 PyObject *resultobj = 0;
44119 wxControl *arg1 = (wxControl *) 0 ;
44120 wxCommandEvent *arg2 = 0 ;
44121 void *argp1 = 0 ;
44122 int res1 = 0 ;
44123 void *argp2 = 0 ;
44124 int res2 = 0 ;
44125 PyObject * obj0 = 0 ;
44126 PyObject * obj1 = 0 ;
44127 char * kwnames[] = {
44128 (char *) "self",(char *) "event", NULL
44129 };
44130
44131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44133 if (!SWIG_IsOK(res1)) {
44134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44135 }
44136 arg1 = reinterpret_cast< wxControl * >(argp1);
44137 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44138 if (!SWIG_IsOK(res2)) {
44139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44140 }
44141 if (!argp2) {
44142 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44143 }
44144 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44145 {
44146 PyThreadState* __tstate = wxPyBeginAllowThreads();
44147 (arg1)->Command(*arg2);
44148 wxPyEndAllowThreads(__tstate);
44149 if (PyErr_Occurred()) SWIG_fail;
44150 }
44151 resultobj = SWIG_Py_Void();
44152 return resultobj;
44153 fail:
44154 return NULL;
44155 }
44156
44157
44158 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44159 PyObject *resultobj = 0;
44160 wxControl *arg1 = (wxControl *) 0 ;
44161 wxString result;
44162 void *argp1 = 0 ;
44163 int res1 = 0 ;
44164 PyObject *swig_obj[1] ;
44165
44166 if (!args) SWIG_fail;
44167 swig_obj[0] = args;
44168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44169 if (!SWIG_IsOK(res1)) {
44170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44171 }
44172 arg1 = reinterpret_cast< wxControl * >(argp1);
44173 {
44174 PyThreadState* __tstate = wxPyBeginAllowThreads();
44175 result = (arg1)->GetLabel();
44176 wxPyEndAllowThreads(__tstate);
44177 if (PyErr_Occurred()) SWIG_fail;
44178 }
44179 {
44180 #if wxUSE_UNICODE
44181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44182 #else
44183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44184 #endif
44185 }
44186 return resultobj;
44187 fail:
44188 return NULL;
44189 }
44190
44191
44192 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44193 PyObject *resultobj = 0;
44194 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44195 SwigValueWrapper<wxVisualAttributes > result;
44196 int val1 ;
44197 int ecode1 = 0 ;
44198 PyObject * obj0 = 0 ;
44199 char * kwnames[] = {
44200 (char *) "variant", NULL
44201 };
44202
44203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44204 if (obj0) {
44205 ecode1 = SWIG_AsVal_int(obj0, &val1);
44206 if (!SWIG_IsOK(ecode1)) {
44207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44208 }
44209 arg1 = static_cast< wxWindowVariant >(val1);
44210 }
44211 {
44212 if (!wxPyCheckForApp()) SWIG_fail;
44213 PyThreadState* __tstate = wxPyBeginAllowThreads();
44214 result = wxControl::GetClassDefaultAttributes(arg1);
44215 wxPyEndAllowThreads(__tstate);
44216 if (PyErr_Occurred()) SWIG_fail;
44217 }
44218 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44219 return resultobj;
44220 fail:
44221 return NULL;
44222 }
44223
44224
44225 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44226 PyObject *obj;
44227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44228 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44229 return SWIG_Py_Void();
44230 }
44231
44232 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44233 return SWIG_Python_InitShadowInstance(args);
44234 }
44235
44236 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44237 PyObject *resultobj = 0;
44238 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44239 wxString *arg2 = 0 ;
44240 PyObject *arg3 = (PyObject *) NULL ;
44241 int result;
44242 void *argp1 = 0 ;
44243 int res1 = 0 ;
44244 bool temp2 = false ;
44245 PyObject * obj0 = 0 ;
44246 PyObject * obj1 = 0 ;
44247 PyObject * obj2 = 0 ;
44248 char * kwnames[] = {
44249 (char *) "self",(char *) "item",(char *) "clientData", NULL
44250 };
44251
44252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44254 if (!SWIG_IsOK(res1)) {
44255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44256 }
44257 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44258 {
44259 arg2 = wxString_in_helper(obj1);
44260 if (arg2 == NULL) SWIG_fail;
44261 temp2 = true;
44262 }
44263 if (obj2) {
44264 arg3 = obj2;
44265 }
44266 {
44267 PyThreadState* __tstate = wxPyBeginAllowThreads();
44268 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44269 wxPyEndAllowThreads(__tstate);
44270 if (PyErr_Occurred()) SWIG_fail;
44271 }
44272 resultobj = SWIG_From_int(static_cast< int >(result));
44273 {
44274 if (temp2)
44275 delete arg2;
44276 }
44277 return resultobj;
44278 fail:
44279 {
44280 if (temp2)
44281 delete arg2;
44282 }
44283 return NULL;
44284 }
44285
44286
44287 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44288 PyObject *resultobj = 0;
44289 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44290 wxArrayString *arg2 = 0 ;
44291 void *argp1 = 0 ;
44292 int res1 = 0 ;
44293 bool temp2 = false ;
44294 PyObject * obj0 = 0 ;
44295 PyObject * obj1 = 0 ;
44296 char * kwnames[] = {
44297 (char *) "self",(char *) "strings", NULL
44298 };
44299
44300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44302 if (!SWIG_IsOK(res1)) {
44303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44304 }
44305 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44306 {
44307 if (! PySequence_Check(obj1)) {
44308 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44309 SWIG_fail;
44310 }
44311 arg2 = new wxArrayString;
44312 temp2 = true;
44313 int i, len=PySequence_Length(obj1);
44314 for (i=0; i<len; i++) {
44315 PyObject* item = PySequence_GetItem(obj1, i);
44316 wxString* s = wxString_in_helper(item);
44317 if (PyErr_Occurred()) SWIG_fail;
44318 arg2->Add(*s);
44319 delete s;
44320 Py_DECREF(item);
44321 }
44322 }
44323 {
44324 PyThreadState* __tstate = wxPyBeginAllowThreads();
44325 (arg1)->Append((wxArrayString const &)*arg2);
44326 wxPyEndAllowThreads(__tstate);
44327 if (PyErr_Occurred()) SWIG_fail;
44328 }
44329 resultobj = SWIG_Py_Void();
44330 {
44331 if (temp2) delete arg2;
44332 }
44333 return resultobj;
44334 fail:
44335 {
44336 if (temp2) delete arg2;
44337 }
44338 return NULL;
44339 }
44340
44341
44342 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44343 PyObject *resultobj = 0;
44344 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44345 wxString *arg2 = 0 ;
44346 unsigned int arg3 ;
44347 PyObject *arg4 = (PyObject *) NULL ;
44348 int result;
44349 void *argp1 = 0 ;
44350 int res1 = 0 ;
44351 bool temp2 = false ;
44352 unsigned int val3 ;
44353 int ecode3 = 0 ;
44354 PyObject * obj0 = 0 ;
44355 PyObject * obj1 = 0 ;
44356 PyObject * obj2 = 0 ;
44357 PyObject * obj3 = 0 ;
44358 char * kwnames[] = {
44359 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44360 };
44361
44362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44364 if (!SWIG_IsOK(res1)) {
44365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44366 }
44367 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44368 {
44369 arg2 = wxString_in_helper(obj1);
44370 if (arg2 == NULL) SWIG_fail;
44371 temp2 = true;
44372 }
44373 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44374 if (!SWIG_IsOK(ecode3)) {
44375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44376 }
44377 arg3 = static_cast< unsigned int >(val3);
44378 if (obj3) {
44379 arg4 = obj3;
44380 }
44381 {
44382 PyThreadState* __tstate = wxPyBeginAllowThreads();
44383 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44384 wxPyEndAllowThreads(__tstate);
44385 if (PyErr_Occurred()) SWIG_fail;
44386 }
44387 resultobj = SWIG_From_int(static_cast< int >(result));
44388 {
44389 if (temp2)
44390 delete arg2;
44391 }
44392 return resultobj;
44393 fail:
44394 {
44395 if (temp2)
44396 delete arg2;
44397 }
44398 return NULL;
44399 }
44400
44401
44402 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44403 PyObject *resultobj = 0;
44404 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44405 void *argp1 = 0 ;
44406 int res1 = 0 ;
44407 PyObject *swig_obj[1] ;
44408
44409 if (!args) SWIG_fail;
44410 swig_obj[0] = args;
44411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44412 if (!SWIG_IsOK(res1)) {
44413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44414 }
44415 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44416 {
44417 PyThreadState* __tstate = wxPyBeginAllowThreads();
44418 (arg1)->Clear();
44419 wxPyEndAllowThreads(__tstate);
44420 if (PyErr_Occurred()) SWIG_fail;
44421 }
44422 resultobj = SWIG_Py_Void();
44423 return resultobj;
44424 fail:
44425 return NULL;
44426 }
44427
44428
44429 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44430 PyObject *resultobj = 0;
44431 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44432 unsigned int arg2 ;
44433 void *argp1 = 0 ;
44434 int res1 = 0 ;
44435 unsigned int val2 ;
44436 int ecode2 = 0 ;
44437 PyObject * obj0 = 0 ;
44438 PyObject * obj1 = 0 ;
44439 char * kwnames[] = {
44440 (char *) "self",(char *) "n", NULL
44441 };
44442
44443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44445 if (!SWIG_IsOK(res1)) {
44446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44447 }
44448 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44449 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44450 if (!SWIG_IsOK(ecode2)) {
44451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44452 }
44453 arg2 = static_cast< unsigned int >(val2);
44454 {
44455 PyThreadState* __tstate = wxPyBeginAllowThreads();
44456 (arg1)->Delete(arg2);
44457 wxPyEndAllowThreads(__tstate);
44458 if (PyErr_Occurred()) SWIG_fail;
44459 }
44460 resultobj = SWIG_Py_Void();
44461 return resultobj;
44462 fail:
44463 return NULL;
44464 }
44465
44466
44467 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44468 PyObject *resultobj = 0;
44469 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44470 unsigned int arg2 ;
44471 PyObject *result = 0 ;
44472 void *argp1 = 0 ;
44473 int res1 = 0 ;
44474 unsigned int val2 ;
44475 int ecode2 = 0 ;
44476 PyObject * obj0 = 0 ;
44477 PyObject * obj1 = 0 ;
44478 char * kwnames[] = {
44479 (char *) "self",(char *) "n", NULL
44480 };
44481
44482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44484 if (!SWIG_IsOK(res1)) {
44485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44486 }
44487 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44488 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44489 if (!SWIG_IsOK(ecode2)) {
44490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44491 }
44492 arg2 = static_cast< unsigned int >(val2);
44493 {
44494 PyThreadState* __tstate = wxPyBeginAllowThreads();
44495 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44496 wxPyEndAllowThreads(__tstate);
44497 if (PyErr_Occurred()) SWIG_fail;
44498 }
44499 resultobj = result;
44500 return resultobj;
44501 fail:
44502 return NULL;
44503 }
44504
44505
44506 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44507 PyObject *resultobj = 0;
44508 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44509 unsigned int arg2 ;
44510 PyObject *arg3 = (PyObject *) 0 ;
44511 void *argp1 = 0 ;
44512 int res1 = 0 ;
44513 unsigned int val2 ;
44514 int ecode2 = 0 ;
44515 PyObject * obj0 = 0 ;
44516 PyObject * obj1 = 0 ;
44517 PyObject * obj2 = 0 ;
44518 char * kwnames[] = {
44519 (char *) "self",(char *) "n",(char *) "clientData", NULL
44520 };
44521
44522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44524 if (!SWIG_IsOK(res1)) {
44525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44526 }
44527 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44528 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44529 if (!SWIG_IsOK(ecode2)) {
44530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44531 }
44532 arg2 = static_cast< unsigned int >(val2);
44533 arg3 = obj2;
44534 {
44535 PyThreadState* __tstate = wxPyBeginAllowThreads();
44536 wxItemContainer_SetClientData(arg1,arg2,arg3);
44537 wxPyEndAllowThreads(__tstate);
44538 if (PyErr_Occurred()) SWIG_fail;
44539 }
44540 resultobj = SWIG_Py_Void();
44541 return resultobj;
44542 fail:
44543 return NULL;
44544 }
44545
44546
44547 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44548 PyObject *resultobj = 0;
44549 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44550 unsigned int result;
44551 void *argp1 = 0 ;
44552 int res1 = 0 ;
44553 PyObject *swig_obj[1] ;
44554
44555 if (!args) SWIG_fail;
44556 swig_obj[0] = args;
44557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44558 if (!SWIG_IsOK(res1)) {
44559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44560 }
44561 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44562 {
44563 PyThreadState* __tstate = wxPyBeginAllowThreads();
44564 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44565 wxPyEndAllowThreads(__tstate);
44566 if (PyErr_Occurred()) SWIG_fail;
44567 }
44568 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44569 return resultobj;
44570 fail:
44571 return NULL;
44572 }
44573
44574
44575 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44576 PyObject *resultobj = 0;
44577 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44578 bool result;
44579 void *argp1 = 0 ;
44580 int res1 = 0 ;
44581 PyObject *swig_obj[1] ;
44582
44583 if (!args) SWIG_fail;
44584 swig_obj[0] = args;
44585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44586 if (!SWIG_IsOK(res1)) {
44587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44588 }
44589 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44590 {
44591 PyThreadState* __tstate = wxPyBeginAllowThreads();
44592 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44593 wxPyEndAllowThreads(__tstate);
44594 if (PyErr_Occurred()) SWIG_fail;
44595 }
44596 {
44597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44598 }
44599 return resultobj;
44600 fail:
44601 return NULL;
44602 }
44603
44604
44605 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44606 PyObject *resultobj = 0;
44607 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44608 unsigned int arg2 ;
44609 wxString result;
44610 void *argp1 = 0 ;
44611 int res1 = 0 ;
44612 unsigned int val2 ;
44613 int ecode2 = 0 ;
44614 PyObject * obj0 = 0 ;
44615 PyObject * obj1 = 0 ;
44616 char * kwnames[] = {
44617 (char *) "self",(char *) "n", NULL
44618 };
44619
44620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44622 if (!SWIG_IsOK(res1)) {
44623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44624 }
44625 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44626 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44627 if (!SWIG_IsOK(ecode2)) {
44628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44629 }
44630 arg2 = static_cast< unsigned int >(val2);
44631 {
44632 PyThreadState* __tstate = wxPyBeginAllowThreads();
44633 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44634 wxPyEndAllowThreads(__tstate);
44635 if (PyErr_Occurred()) SWIG_fail;
44636 }
44637 {
44638 #if wxUSE_UNICODE
44639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44640 #else
44641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44642 #endif
44643 }
44644 return resultobj;
44645 fail:
44646 return NULL;
44647 }
44648
44649
44650 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44651 PyObject *resultobj = 0;
44652 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44653 wxArrayString result;
44654 void *argp1 = 0 ;
44655 int res1 = 0 ;
44656 PyObject *swig_obj[1] ;
44657
44658 if (!args) SWIG_fail;
44659 swig_obj[0] = args;
44660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44661 if (!SWIG_IsOK(res1)) {
44662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44663 }
44664 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44665 {
44666 PyThreadState* __tstate = wxPyBeginAllowThreads();
44667 result = ((wxItemContainer const *)arg1)->GetStrings();
44668 wxPyEndAllowThreads(__tstate);
44669 if (PyErr_Occurred()) SWIG_fail;
44670 }
44671 {
44672 resultobj = wxArrayString2PyList_helper(result);
44673 }
44674 return resultobj;
44675 fail:
44676 return NULL;
44677 }
44678
44679
44680 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44681 PyObject *resultobj = 0;
44682 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44683 unsigned int arg2 ;
44684 wxString *arg3 = 0 ;
44685 void *argp1 = 0 ;
44686 int res1 = 0 ;
44687 unsigned int val2 ;
44688 int ecode2 = 0 ;
44689 bool temp3 = false ;
44690 PyObject * obj0 = 0 ;
44691 PyObject * obj1 = 0 ;
44692 PyObject * obj2 = 0 ;
44693 char * kwnames[] = {
44694 (char *) "self",(char *) "n",(char *) "s", NULL
44695 };
44696
44697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44699 if (!SWIG_IsOK(res1)) {
44700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44701 }
44702 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44703 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44704 if (!SWIG_IsOK(ecode2)) {
44705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44706 }
44707 arg2 = static_cast< unsigned int >(val2);
44708 {
44709 arg3 = wxString_in_helper(obj2);
44710 if (arg3 == NULL) SWIG_fail;
44711 temp3 = true;
44712 }
44713 {
44714 PyThreadState* __tstate = wxPyBeginAllowThreads();
44715 (arg1)->SetString(arg2,(wxString const &)*arg3);
44716 wxPyEndAllowThreads(__tstate);
44717 if (PyErr_Occurred()) SWIG_fail;
44718 }
44719 resultobj = SWIG_Py_Void();
44720 {
44721 if (temp3)
44722 delete arg3;
44723 }
44724 return resultobj;
44725 fail:
44726 {
44727 if (temp3)
44728 delete arg3;
44729 }
44730 return NULL;
44731 }
44732
44733
44734 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44735 PyObject *resultobj = 0;
44736 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44737 wxString *arg2 = 0 ;
44738 int result;
44739 void *argp1 = 0 ;
44740 int res1 = 0 ;
44741 bool temp2 = false ;
44742 PyObject * obj0 = 0 ;
44743 PyObject * obj1 = 0 ;
44744 char * kwnames[] = {
44745 (char *) "self",(char *) "s", NULL
44746 };
44747
44748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44750 if (!SWIG_IsOK(res1)) {
44751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44752 }
44753 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44754 {
44755 arg2 = wxString_in_helper(obj1);
44756 if (arg2 == NULL) SWIG_fail;
44757 temp2 = true;
44758 }
44759 {
44760 PyThreadState* __tstate = wxPyBeginAllowThreads();
44761 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44762 wxPyEndAllowThreads(__tstate);
44763 if (PyErr_Occurred()) SWIG_fail;
44764 }
44765 resultobj = SWIG_From_int(static_cast< int >(result));
44766 {
44767 if (temp2)
44768 delete arg2;
44769 }
44770 return resultobj;
44771 fail:
44772 {
44773 if (temp2)
44774 delete arg2;
44775 }
44776 return NULL;
44777 }
44778
44779
44780 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44781 PyObject *resultobj = 0;
44782 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44783 int arg2 ;
44784 void *argp1 = 0 ;
44785 int res1 = 0 ;
44786 int val2 ;
44787 int ecode2 = 0 ;
44788 PyObject * obj0 = 0 ;
44789 PyObject * obj1 = 0 ;
44790 char * kwnames[] = {
44791 (char *) "self",(char *) "n", NULL
44792 };
44793
44794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44796 if (!SWIG_IsOK(res1)) {
44797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44798 }
44799 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44800 ecode2 = SWIG_AsVal_int(obj1, &val2);
44801 if (!SWIG_IsOK(ecode2)) {
44802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44803 }
44804 arg2 = static_cast< int >(val2);
44805 {
44806 PyThreadState* __tstate = wxPyBeginAllowThreads();
44807 (arg1)->SetSelection(arg2);
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 resultobj = SWIG_Py_Void();
44812 return resultobj;
44813 fail:
44814 return NULL;
44815 }
44816
44817
44818 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44819 PyObject *resultobj = 0;
44820 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44821 int result;
44822 void *argp1 = 0 ;
44823 int res1 = 0 ;
44824 PyObject *swig_obj[1] ;
44825
44826 if (!args) SWIG_fail;
44827 swig_obj[0] = args;
44828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44829 if (!SWIG_IsOK(res1)) {
44830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44831 }
44832 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44833 {
44834 PyThreadState* __tstate = wxPyBeginAllowThreads();
44835 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44836 wxPyEndAllowThreads(__tstate);
44837 if (PyErr_Occurred()) SWIG_fail;
44838 }
44839 resultobj = SWIG_From_int(static_cast< int >(result));
44840 return resultobj;
44841 fail:
44842 return NULL;
44843 }
44844
44845
44846 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44847 PyObject *resultobj = 0;
44848 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44849 wxString *arg2 = 0 ;
44850 bool result;
44851 void *argp1 = 0 ;
44852 int res1 = 0 ;
44853 bool temp2 = false ;
44854 PyObject * obj0 = 0 ;
44855 PyObject * obj1 = 0 ;
44856 char * kwnames[] = {
44857 (char *) "self",(char *) "s", NULL
44858 };
44859
44860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44862 if (!SWIG_IsOK(res1)) {
44863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44864 }
44865 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44866 {
44867 arg2 = wxString_in_helper(obj1);
44868 if (arg2 == NULL) SWIG_fail;
44869 temp2 = true;
44870 }
44871 {
44872 PyThreadState* __tstate = wxPyBeginAllowThreads();
44873 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44874 wxPyEndAllowThreads(__tstate);
44875 if (PyErr_Occurred()) SWIG_fail;
44876 }
44877 {
44878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44879 }
44880 {
44881 if (temp2)
44882 delete arg2;
44883 }
44884 return resultobj;
44885 fail:
44886 {
44887 if (temp2)
44888 delete arg2;
44889 }
44890 return NULL;
44891 }
44892
44893
44894 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44895 PyObject *resultobj = 0;
44896 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44897 wxString result;
44898 void *argp1 = 0 ;
44899 int res1 = 0 ;
44900 PyObject *swig_obj[1] ;
44901
44902 if (!args) SWIG_fail;
44903 swig_obj[0] = args;
44904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44905 if (!SWIG_IsOK(res1)) {
44906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44907 }
44908 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44909 {
44910 PyThreadState* __tstate = wxPyBeginAllowThreads();
44911 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44912 wxPyEndAllowThreads(__tstate);
44913 if (PyErr_Occurred()) SWIG_fail;
44914 }
44915 {
44916 #if wxUSE_UNICODE
44917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44918 #else
44919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44920 #endif
44921 }
44922 return resultobj;
44923 fail:
44924 return NULL;
44925 }
44926
44927
44928 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44929 PyObject *resultobj = 0;
44930 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44931 int arg2 ;
44932 void *argp1 = 0 ;
44933 int res1 = 0 ;
44934 int val2 ;
44935 int ecode2 = 0 ;
44936 PyObject * obj0 = 0 ;
44937 PyObject * obj1 = 0 ;
44938 char * kwnames[] = {
44939 (char *) "self",(char *) "n", NULL
44940 };
44941
44942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44944 if (!SWIG_IsOK(res1)) {
44945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44946 }
44947 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44948 ecode2 = SWIG_AsVal_int(obj1, &val2);
44949 if (!SWIG_IsOK(ecode2)) {
44950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44951 }
44952 arg2 = static_cast< int >(val2);
44953 {
44954 PyThreadState* __tstate = wxPyBeginAllowThreads();
44955 (arg1)->Select(arg2);
44956 wxPyEndAllowThreads(__tstate);
44957 if (PyErr_Occurred()) SWIG_fail;
44958 }
44959 resultobj = SWIG_Py_Void();
44960 return resultobj;
44961 fail:
44962 return NULL;
44963 }
44964
44965
44966 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44967 PyObject *obj;
44968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44969 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44970 return SWIG_Py_Void();
44971 }
44972
44973 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44974 PyObject *obj;
44975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44976 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44977 return SWIG_Py_Void();
44978 }
44979
44980 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44981 PyObject *resultobj = 0;
44982 wxSizerItem *result = 0 ;
44983
44984 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44985 {
44986 PyThreadState* __tstate = wxPyBeginAllowThreads();
44987 result = (wxSizerItem *)new wxSizerItem();
44988 wxPyEndAllowThreads(__tstate);
44989 if (PyErr_Occurred()) SWIG_fail;
44990 }
44991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44992 return resultobj;
44993 fail:
44994 return NULL;
44995 }
44996
44997
44998 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44999 PyObject *resultobj = 0;
45000 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45001 void *argp1 = 0 ;
45002 int res1 = 0 ;
45003 PyObject *swig_obj[1] ;
45004
45005 if (!args) SWIG_fail;
45006 swig_obj[0] = args;
45007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45008 if (!SWIG_IsOK(res1)) {
45009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45010 }
45011 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45012 {
45013 PyThreadState* __tstate = wxPyBeginAllowThreads();
45014 delete arg1;
45015
45016 wxPyEndAllowThreads(__tstate);
45017 if (PyErr_Occurred()) SWIG_fail;
45018 }
45019 resultobj = SWIG_Py_Void();
45020 return resultobj;
45021 fail:
45022 return NULL;
45023 }
45024
45025
45026 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45027 PyObject *resultobj = 0;
45028 wxWindow *arg1 = (wxWindow *) 0 ;
45029 int arg2 ;
45030 int arg3 ;
45031 int arg4 ;
45032 PyObject *arg5 = (PyObject *) NULL ;
45033 wxSizerItem *result = 0 ;
45034 void *argp1 = 0 ;
45035 int res1 = 0 ;
45036 int val2 ;
45037 int ecode2 = 0 ;
45038 int val3 ;
45039 int ecode3 = 0 ;
45040 int val4 ;
45041 int ecode4 = 0 ;
45042 PyObject * obj0 = 0 ;
45043 PyObject * obj1 = 0 ;
45044 PyObject * obj2 = 0 ;
45045 PyObject * obj3 = 0 ;
45046 PyObject * obj4 = 0 ;
45047 char * kwnames[] = {
45048 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45049 };
45050
45051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45053 if (!SWIG_IsOK(res1)) {
45054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45055 }
45056 arg1 = reinterpret_cast< wxWindow * >(argp1);
45057 ecode2 = SWIG_AsVal_int(obj1, &val2);
45058 if (!SWIG_IsOK(ecode2)) {
45059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45060 }
45061 arg2 = static_cast< int >(val2);
45062 ecode3 = SWIG_AsVal_int(obj2, &val3);
45063 if (!SWIG_IsOK(ecode3)) {
45064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45065 }
45066 arg3 = static_cast< int >(val3);
45067 ecode4 = SWIG_AsVal_int(obj3, &val4);
45068 if (!SWIG_IsOK(ecode4)) {
45069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45070 }
45071 arg4 = static_cast< int >(val4);
45072 if (obj4) {
45073 arg5 = obj4;
45074 }
45075 {
45076 PyThreadState* __tstate = wxPyBeginAllowThreads();
45077 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45078 wxPyEndAllowThreads(__tstate);
45079 if (PyErr_Occurred()) SWIG_fail;
45080 }
45081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45082 return resultobj;
45083 fail:
45084 return NULL;
45085 }
45086
45087
45088 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45089 PyObject *resultobj = 0;
45090 int arg1 ;
45091 int arg2 ;
45092 int arg3 ;
45093 int arg4 ;
45094 int arg5 ;
45095 PyObject *arg6 = (PyObject *) NULL ;
45096 wxSizerItem *result = 0 ;
45097 int val1 ;
45098 int ecode1 = 0 ;
45099 int val2 ;
45100 int ecode2 = 0 ;
45101 int val3 ;
45102 int ecode3 = 0 ;
45103 int val4 ;
45104 int ecode4 = 0 ;
45105 int val5 ;
45106 int ecode5 = 0 ;
45107 PyObject * obj0 = 0 ;
45108 PyObject * obj1 = 0 ;
45109 PyObject * obj2 = 0 ;
45110 PyObject * obj3 = 0 ;
45111 PyObject * obj4 = 0 ;
45112 PyObject * obj5 = 0 ;
45113 char * kwnames[] = {
45114 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45115 };
45116
45117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45118 ecode1 = SWIG_AsVal_int(obj0, &val1);
45119 if (!SWIG_IsOK(ecode1)) {
45120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45121 }
45122 arg1 = static_cast< int >(val1);
45123 ecode2 = SWIG_AsVal_int(obj1, &val2);
45124 if (!SWIG_IsOK(ecode2)) {
45125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45126 }
45127 arg2 = static_cast< int >(val2);
45128 ecode3 = SWIG_AsVal_int(obj2, &val3);
45129 if (!SWIG_IsOK(ecode3)) {
45130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45131 }
45132 arg3 = static_cast< int >(val3);
45133 ecode4 = SWIG_AsVal_int(obj3, &val4);
45134 if (!SWIG_IsOK(ecode4)) {
45135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45136 }
45137 arg4 = static_cast< int >(val4);
45138 ecode5 = SWIG_AsVal_int(obj4, &val5);
45139 if (!SWIG_IsOK(ecode5)) {
45140 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45141 }
45142 arg5 = static_cast< int >(val5);
45143 if (obj5) {
45144 arg6 = obj5;
45145 }
45146 {
45147 PyThreadState* __tstate = wxPyBeginAllowThreads();
45148 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45149 wxPyEndAllowThreads(__tstate);
45150 if (PyErr_Occurred()) SWIG_fail;
45151 }
45152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45153 return resultobj;
45154 fail:
45155 return NULL;
45156 }
45157
45158
45159 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45160 PyObject *resultobj = 0;
45161 wxSizer *arg1 = (wxSizer *) 0 ;
45162 int arg2 ;
45163 int arg3 ;
45164 int arg4 ;
45165 PyObject *arg5 = (PyObject *) NULL ;
45166 wxSizerItem *result = 0 ;
45167 int res1 = 0 ;
45168 int val2 ;
45169 int ecode2 = 0 ;
45170 int val3 ;
45171 int ecode3 = 0 ;
45172 int val4 ;
45173 int ecode4 = 0 ;
45174 PyObject * obj0 = 0 ;
45175 PyObject * obj1 = 0 ;
45176 PyObject * obj2 = 0 ;
45177 PyObject * obj3 = 0 ;
45178 PyObject * obj4 = 0 ;
45179 char * kwnames[] = {
45180 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45181 };
45182
45183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45184 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45185 if (!SWIG_IsOK(res1)) {
45186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45187 }
45188 ecode2 = SWIG_AsVal_int(obj1, &val2);
45189 if (!SWIG_IsOK(ecode2)) {
45190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45191 }
45192 arg2 = static_cast< int >(val2);
45193 ecode3 = SWIG_AsVal_int(obj2, &val3);
45194 if (!SWIG_IsOK(ecode3)) {
45195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45196 }
45197 arg3 = static_cast< int >(val3);
45198 ecode4 = SWIG_AsVal_int(obj3, &val4);
45199 if (!SWIG_IsOK(ecode4)) {
45200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45201 }
45202 arg4 = static_cast< int >(val4);
45203 if (obj4) {
45204 arg5 = obj4;
45205 }
45206 {
45207 PyThreadState* __tstate = wxPyBeginAllowThreads();
45208 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45209 wxPyEndAllowThreads(__tstate);
45210 if (PyErr_Occurred()) SWIG_fail;
45211 }
45212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45213 return resultobj;
45214 fail:
45215 return NULL;
45216 }
45217
45218
45219 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45220 PyObject *resultobj = 0;
45221 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45222 void *argp1 = 0 ;
45223 int res1 = 0 ;
45224 PyObject *swig_obj[1] ;
45225
45226 if (!args) SWIG_fail;
45227 swig_obj[0] = args;
45228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45229 if (!SWIG_IsOK(res1)) {
45230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45231 }
45232 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45233 {
45234 PyThreadState* __tstate = wxPyBeginAllowThreads();
45235 (arg1)->DeleteWindows();
45236 wxPyEndAllowThreads(__tstate);
45237 if (PyErr_Occurred()) SWIG_fail;
45238 }
45239 resultobj = SWIG_Py_Void();
45240 return resultobj;
45241 fail:
45242 return NULL;
45243 }
45244
45245
45246 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45247 PyObject *resultobj = 0;
45248 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45249 void *argp1 = 0 ;
45250 int res1 = 0 ;
45251 PyObject *swig_obj[1] ;
45252
45253 if (!args) SWIG_fail;
45254 swig_obj[0] = args;
45255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45256 if (!SWIG_IsOK(res1)) {
45257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45258 }
45259 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45260 {
45261 PyThreadState* __tstate = wxPyBeginAllowThreads();
45262 (arg1)->DetachSizer();
45263 wxPyEndAllowThreads(__tstate);
45264 if (PyErr_Occurred()) SWIG_fail;
45265 }
45266 resultobj = SWIG_Py_Void();
45267 return resultobj;
45268 fail:
45269 return NULL;
45270 }
45271
45272
45273 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45274 PyObject *resultobj = 0;
45275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45276 wxSize result;
45277 void *argp1 = 0 ;
45278 int res1 = 0 ;
45279 PyObject *swig_obj[1] ;
45280
45281 if (!args) SWIG_fail;
45282 swig_obj[0] = args;
45283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45284 if (!SWIG_IsOK(res1)) {
45285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45286 }
45287 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45288 {
45289 PyThreadState* __tstate = wxPyBeginAllowThreads();
45290 result = (arg1)->GetSize();
45291 wxPyEndAllowThreads(__tstate);
45292 if (PyErr_Occurred()) SWIG_fail;
45293 }
45294 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45295 return resultobj;
45296 fail:
45297 return NULL;
45298 }
45299
45300
45301 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45302 PyObject *resultobj = 0;
45303 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45304 wxSize result;
45305 void *argp1 = 0 ;
45306 int res1 = 0 ;
45307 PyObject *swig_obj[1] ;
45308
45309 if (!args) SWIG_fail;
45310 swig_obj[0] = args;
45311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45312 if (!SWIG_IsOK(res1)) {
45313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45314 }
45315 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45316 {
45317 PyThreadState* __tstate = wxPyBeginAllowThreads();
45318 result = (arg1)->CalcMin();
45319 wxPyEndAllowThreads(__tstate);
45320 if (PyErr_Occurred()) SWIG_fail;
45321 }
45322 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45323 return resultobj;
45324 fail:
45325 return NULL;
45326 }
45327
45328
45329 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45330 PyObject *resultobj = 0;
45331 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45332 wxPoint *arg2 = 0 ;
45333 wxSize *arg3 = 0 ;
45334 void *argp1 = 0 ;
45335 int res1 = 0 ;
45336 wxPoint temp2 ;
45337 wxSize temp3 ;
45338 PyObject * obj0 = 0 ;
45339 PyObject * obj1 = 0 ;
45340 PyObject * obj2 = 0 ;
45341 char * kwnames[] = {
45342 (char *) "self",(char *) "pos",(char *) "size", NULL
45343 };
45344
45345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45347 if (!SWIG_IsOK(res1)) {
45348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45349 }
45350 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45351 {
45352 arg2 = &temp2;
45353 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45354 }
45355 {
45356 arg3 = &temp3;
45357 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45358 }
45359 {
45360 PyThreadState* __tstate = wxPyBeginAllowThreads();
45361 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45362 wxPyEndAllowThreads(__tstate);
45363 if (PyErr_Occurred()) SWIG_fail;
45364 }
45365 resultobj = SWIG_Py_Void();
45366 return resultobj;
45367 fail:
45368 return NULL;
45369 }
45370
45371
45372 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45373 PyObject *resultobj = 0;
45374 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45375 wxSize result;
45376 void *argp1 = 0 ;
45377 int res1 = 0 ;
45378 PyObject *swig_obj[1] ;
45379
45380 if (!args) SWIG_fail;
45381 swig_obj[0] = args;
45382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45383 if (!SWIG_IsOK(res1)) {
45384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45385 }
45386 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45387 {
45388 PyThreadState* __tstate = wxPyBeginAllowThreads();
45389 result = (arg1)->GetMinSize();
45390 wxPyEndAllowThreads(__tstate);
45391 if (PyErr_Occurred()) SWIG_fail;
45392 }
45393 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45394 return resultobj;
45395 fail:
45396 return NULL;
45397 }
45398
45399
45400 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45401 PyObject *resultobj = 0;
45402 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45403 wxSize result;
45404 void *argp1 = 0 ;
45405 int res1 = 0 ;
45406 PyObject *swig_obj[1] ;
45407
45408 if (!args) SWIG_fail;
45409 swig_obj[0] = args;
45410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45411 if (!SWIG_IsOK(res1)) {
45412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45413 }
45414 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45415 {
45416 PyThreadState* __tstate = wxPyBeginAllowThreads();
45417 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45418 wxPyEndAllowThreads(__tstate);
45419 if (PyErr_Occurred()) SWIG_fail;
45420 }
45421 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45422 return resultobj;
45423 fail:
45424 return NULL;
45425 }
45426
45427
45428 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45429 PyObject *resultobj = 0;
45430 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45431 int arg2 ;
45432 int arg3 ;
45433 void *argp1 = 0 ;
45434 int res1 = 0 ;
45435 int val2 ;
45436 int ecode2 = 0 ;
45437 int val3 ;
45438 int ecode3 = 0 ;
45439 PyObject * obj0 = 0 ;
45440 PyObject * obj1 = 0 ;
45441 PyObject * obj2 = 0 ;
45442 char * kwnames[] = {
45443 (char *) "self",(char *) "x",(char *) "y", NULL
45444 };
45445
45446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45448 if (!SWIG_IsOK(res1)) {
45449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45450 }
45451 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45452 ecode2 = SWIG_AsVal_int(obj1, &val2);
45453 if (!SWIG_IsOK(ecode2)) {
45454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45455 }
45456 arg2 = static_cast< int >(val2);
45457 ecode3 = SWIG_AsVal_int(obj2, &val3);
45458 if (!SWIG_IsOK(ecode3)) {
45459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45460 }
45461 arg3 = static_cast< int >(val3);
45462 {
45463 PyThreadState* __tstate = wxPyBeginAllowThreads();
45464 (arg1)->SetInitSize(arg2,arg3);
45465 wxPyEndAllowThreads(__tstate);
45466 if (PyErr_Occurred()) SWIG_fail;
45467 }
45468 resultobj = SWIG_Py_Void();
45469 return resultobj;
45470 fail:
45471 return NULL;
45472 }
45473
45474
45475 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45476 PyObject *resultobj = 0;
45477 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45478 int arg2 ;
45479 int arg3 ;
45480 void *argp1 = 0 ;
45481 int res1 = 0 ;
45482 int val2 ;
45483 int ecode2 = 0 ;
45484 int val3 ;
45485 int ecode3 = 0 ;
45486 PyObject * obj0 = 0 ;
45487 PyObject * obj1 = 0 ;
45488 PyObject * obj2 = 0 ;
45489 char * kwnames[] = {
45490 (char *) "self",(char *) "width",(char *) "height", NULL
45491 };
45492
45493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45495 if (!SWIG_IsOK(res1)) {
45496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45497 }
45498 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45499 ecode2 = SWIG_AsVal_int(obj1, &val2);
45500 if (!SWIG_IsOK(ecode2)) {
45501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45502 }
45503 arg2 = static_cast< int >(val2);
45504 ecode3 = SWIG_AsVal_int(obj2, &val3);
45505 if (!SWIG_IsOK(ecode3)) {
45506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45507 }
45508 arg3 = static_cast< int >(val3);
45509 {
45510 PyThreadState* __tstate = wxPyBeginAllowThreads();
45511 (arg1)->SetRatio(arg2,arg3);
45512 wxPyEndAllowThreads(__tstate);
45513 if (PyErr_Occurred()) SWIG_fail;
45514 }
45515 resultobj = SWIG_Py_Void();
45516 return resultobj;
45517 fail:
45518 return NULL;
45519 }
45520
45521
45522 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45523 PyObject *resultobj = 0;
45524 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45525 wxSize *arg2 = 0 ;
45526 void *argp1 = 0 ;
45527 int res1 = 0 ;
45528 wxSize temp2 ;
45529 PyObject * obj0 = 0 ;
45530 PyObject * obj1 = 0 ;
45531 char * kwnames[] = {
45532 (char *) "self",(char *) "size", NULL
45533 };
45534
45535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45537 if (!SWIG_IsOK(res1)) {
45538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45539 }
45540 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45541 {
45542 arg2 = &temp2;
45543 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45544 }
45545 {
45546 PyThreadState* __tstate = wxPyBeginAllowThreads();
45547 (arg1)->SetRatio((wxSize const &)*arg2);
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 resultobj = SWIG_Py_Void();
45552 return resultobj;
45553 fail:
45554 return NULL;
45555 }
45556
45557
45558 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45559 PyObject *resultobj = 0;
45560 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45561 float arg2 ;
45562 void *argp1 = 0 ;
45563 int res1 = 0 ;
45564 float val2 ;
45565 int ecode2 = 0 ;
45566 PyObject * obj0 = 0 ;
45567 PyObject * obj1 = 0 ;
45568 char * kwnames[] = {
45569 (char *) "self",(char *) "ratio", NULL
45570 };
45571
45572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45574 if (!SWIG_IsOK(res1)) {
45575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45576 }
45577 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45578 ecode2 = SWIG_AsVal_float(obj1, &val2);
45579 if (!SWIG_IsOK(ecode2)) {
45580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45581 }
45582 arg2 = static_cast< float >(val2);
45583 {
45584 PyThreadState* __tstate = wxPyBeginAllowThreads();
45585 (arg1)->SetRatio(arg2);
45586 wxPyEndAllowThreads(__tstate);
45587 if (PyErr_Occurred()) SWIG_fail;
45588 }
45589 resultobj = SWIG_Py_Void();
45590 return resultobj;
45591 fail:
45592 return NULL;
45593 }
45594
45595
45596 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45597 PyObject *resultobj = 0;
45598 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45599 float result;
45600 void *argp1 = 0 ;
45601 int res1 = 0 ;
45602 PyObject *swig_obj[1] ;
45603
45604 if (!args) SWIG_fail;
45605 swig_obj[0] = args;
45606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45607 if (!SWIG_IsOK(res1)) {
45608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45609 }
45610 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45611 {
45612 PyThreadState* __tstate = wxPyBeginAllowThreads();
45613 result = (float)(arg1)->GetRatio();
45614 wxPyEndAllowThreads(__tstate);
45615 if (PyErr_Occurred()) SWIG_fail;
45616 }
45617 resultobj = SWIG_From_float(static_cast< float >(result));
45618 return resultobj;
45619 fail:
45620 return NULL;
45621 }
45622
45623
45624 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45625 PyObject *resultobj = 0;
45626 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45627 wxRect result;
45628 void *argp1 = 0 ;
45629 int res1 = 0 ;
45630 PyObject *swig_obj[1] ;
45631
45632 if (!args) SWIG_fail;
45633 swig_obj[0] = args;
45634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45635 if (!SWIG_IsOK(res1)) {
45636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45637 }
45638 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45639 {
45640 PyThreadState* __tstate = wxPyBeginAllowThreads();
45641 result = (arg1)->GetRect();
45642 wxPyEndAllowThreads(__tstate);
45643 if (PyErr_Occurred()) SWIG_fail;
45644 }
45645 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45646 return resultobj;
45647 fail:
45648 return NULL;
45649 }
45650
45651
45652 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45653 PyObject *resultobj = 0;
45654 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45655 bool result;
45656 void *argp1 = 0 ;
45657 int res1 = 0 ;
45658 PyObject *swig_obj[1] ;
45659
45660 if (!args) SWIG_fail;
45661 swig_obj[0] = args;
45662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45663 if (!SWIG_IsOK(res1)) {
45664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45665 }
45666 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45667 {
45668 PyThreadState* __tstate = wxPyBeginAllowThreads();
45669 result = (bool)(arg1)->IsWindow();
45670 wxPyEndAllowThreads(__tstate);
45671 if (PyErr_Occurred()) SWIG_fail;
45672 }
45673 {
45674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45675 }
45676 return resultobj;
45677 fail:
45678 return NULL;
45679 }
45680
45681
45682 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45683 PyObject *resultobj = 0;
45684 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45685 bool result;
45686 void *argp1 = 0 ;
45687 int res1 = 0 ;
45688 PyObject *swig_obj[1] ;
45689
45690 if (!args) SWIG_fail;
45691 swig_obj[0] = args;
45692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45693 if (!SWIG_IsOK(res1)) {
45694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45695 }
45696 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45697 {
45698 PyThreadState* __tstate = wxPyBeginAllowThreads();
45699 result = (bool)(arg1)->IsSizer();
45700 wxPyEndAllowThreads(__tstate);
45701 if (PyErr_Occurred()) SWIG_fail;
45702 }
45703 {
45704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45705 }
45706 return resultobj;
45707 fail:
45708 return NULL;
45709 }
45710
45711
45712 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45713 PyObject *resultobj = 0;
45714 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45715 bool result;
45716 void *argp1 = 0 ;
45717 int res1 = 0 ;
45718 PyObject *swig_obj[1] ;
45719
45720 if (!args) SWIG_fail;
45721 swig_obj[0] = args;
45722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45723 if (!SWIG_IsOK(res1)) {
45724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45725 }
45726 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45727 {
45728 PyThreadState* __tstate = wxPyBeginAllowThreads();
45729 result = (bool)(arg1)->IsSpacer();
45730 wxPyEndAllowThreads(__tstate);
45731 if (PyErr_Occurred()) SWIG_fail;
45732 }
45733 {
45734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45735 }
45736 return resultobj;
45737 fail:
45738 return NULL;
45739 }
45740
45741
45742 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45743 PyObject *resultobj = 0;
45744 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45745 int arg2 ;
45746 void *argp1 = 0 ;
45747 int res1 = 0 ;
45748 int val2 ;
45749 int ecode2 = 0 ;
45750 PyObject * obj0 = 0 ;
45751 PyObject * obj1 = 0 ;
45752 char * kwnames[] = {
45753 (char *) "self",(char *) "proportion", NULL
45754 };
45755
45756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45758 if (!SWIG_IsOK(res1)) {
45759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45760 }
45761 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45762 ecode2 = SWIG_AsVal_int(obj1, &val2);
45763 if (!SWIG_IsOK(ecode2)) {
45764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45765 }
45766 arg2 = static_cast< int >(val2);
45767 {
45768 PyThreadState* __tstate = wxPyBeginAllowThreads();
45769 (arg1)->SetProportion(arg2);
45770 wxPyEndAllowThreads(__tstate);
45771 if (PyErr_Occurred()) SWIG_fail;
45772 }
45773 resultobj = SWIG_Py_Void();
45774 return resultobj;
45775 fail:
45776 return NULL;
45777 }
45778
45779
45780 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45781 PyObject *resultobj = 0;
45782 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45783 int result;
45784 void *argp1 = 0 ;
45785 int res1 = 0 ;
45786 PyObject *swig_obj[1] ;
45787
45788 if (!args) SWIG_fail;
45789 swig_obj[0] = args;
45790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45791 if (!SWIG_IsOK(res1)) {
45792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45793 }
45794 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45795 {
45796 PyThreadState* __tstate = wxPyBeginAllowThreads();
45797 result = (int)(arg1)->GetProportion();
45798 wxPyEndAllowThreads(__tstate);
45799 if (PyErr_Occurred()) SWIG_fail;
45800 }
45801 resultobj = SWIG_From_int(static_cast< int >(result));
45802 return resultobj;
45803 fail:
45804 return NULL;
45805 }
45806
45807
45808 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45809 PyObject *resultobj = 0;
45810 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45811 int arg2 ;
45812 void *argp1 = 0 ;
45813 int res1 = 0 ;
45814 int val2 ;
45815 int ecode2 = 0 ;
45816 PyObject * obj0 = 0 ;
45817 PyObject * obj1 = 0 ;
45818 char * kwnames[] = {
45819 (char *) "self",(char *) "flag", NULL
45820 };
45821
45822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45824 if (!SWIG_IsOK(res1)) {
45825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45826 }
45827 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45828 ecode2 = SWIG_AsVal_int(obj1, &val2);
45829 if (!SWIG_IsOK(ecode2)) {
45830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45831 }
45832 arg2 = static_cast< int >(val2);
45833 {
45834 PyThreadState* __tstate = wxPyBeginAllowThreads();
45835 (arg1)->SetFlag(arg2);
45836 wxPyEndAllowThreads(__tstate);
45837 if (PyErr_Occurred()) SWIG_fail;
45838 }
45839 resultobj = SWIG_Py_Void();
45840 return resultobj;
45841 fail:
45842 return NULL;
45843 }
45844
45845
45846 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45847 PyObject *resultobj = 0;
45848 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45849 int result;
45850 void *argp1 = 0 ;
45851 int res1 = 0 ;
45852 PyObject *swig_obj[1] ;
45853
45854 if (!args) SWIG_fail;
45855 swig_obj[0] = args;
45856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45857 if (!SWIG_IsOK(res1)) {
45858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45859 }
45860 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45861 {
45862 PyThreadState* __tstate = wxPyBeginAllowThreads();
45863 result = (int)(arg1)->GetFlag();
45864 wxPyEndAllowThreads(__tstate);
45865 if (PyErr_Occurred()) SWIG_fail;
45866 }
45867 resultobj = SWIG_From_int(static_cast< int >(result));
45868 return resultobj;
45869 fail:
45870 return NULL;
45871 }
45872
45873
45874 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45875 PyObject *resultobj = 0;
45876 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45877 int arg2 ;
45878 void *argp1 = 0 ;
45879 int res1 = 0 ;
45880 int val2 ;
45881 int ecode2 = 0 ;
45882 PyObject * obj0 = 0 ;
45883 PyObject * obj1 = 0 ;
45884 char * kwnames[] = {
45885 (char *) "self",(char *) "border", NULL
45886 };
45887
45888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45890 if (!SWIG_IsOK(res1)) {
45891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45892 }
45893 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45894 ecode2 = SWIG_AsVal_int(obj1, &val2);
45895 if (!SWIG_IsOK(ecode2)) {
45896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45897 }
45898 arg2 = static_cast< int >(val2);
45899 {
45900 PyThreadState* __tstate = wxPyBeginAllowThreads();
45901 (arg1)->SetBorder(arg2);
45902 wxPyEndAllowThreads(__tstate);
45903 if (PyErr_Occurred()) SWIG_fail;
45904 }
45905 resultobj = SWIG_Py_Void();
45906 return resultobj;
45907 fail:
45908 return NULL;
45909 }
45910
45911
45912 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45913 PyObject *resultobj = 0;
45914 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45915 int result;
45916 void *argp1 = 0 ;
45917 int res1 = 0 ;
45918 PyObject *swig_obj[1] ;
45919
45920 if (!args) SWIG_fail;
45921 swig_obj[0] = args;
45922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45923 if (!SWIG_IsOK(res1)) {
45924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45925 }
45926 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45927 {
45928 PyThreadState* __tstate = wxPyBeginAllowThreads();
45929 result = (int)(arg1)->GetBorder();
45930 wxPyEndAllowThreads(__tstate);
45931 if (PyErr_Occurred()) SWIG_fail;
45932 }
45933 resultobj = SWIG_From_int(static_cast< int >(result));
45934 return resultobj;
45935 fail:
45936 return NULL;
45937 }
45938
45939
45940 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45941 PyObject *resultobj = 0;
45942 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45943 wxWindow *result = 0 ;
45944 void *argp1 = 0 ;
45945 int res1 = 0 ;
45946 PyObject *swig_obj[1] ;
45947
45948 if (!args) SWIG_fail;
45949 swig_obj[0] = args;
45950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45951 if (!SWIG_IsOK(res1)) {
45952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45953 }
45954 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45955 {
45956 PyThreadState* __tstate = wxPyBeginAllowThreads();
45957 result = (wxWindow *)(arg1)->GetWindow();
45958 wxPyEndAllowThreads(__tstate);
45959 if (PyErr_Occurred()) SWIG_fail;
45960 }
45961 {
45962 resultobj = wxPyMake_wxObject(result, 0);
45963 }
45964 return resultobj;
45965 fail:
45966 return NULL;
45967 }
45968
45969
45970 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45971 PyObject *resultobj = 0;
45972 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45973 wxWindow *arg2 = (wxWindow *) 0 ;
45974 void *argp1 = 0 ;
45975 int res1 = 0 ;
45976 void *argp2 = 0 ;
45977 int res2 = 0 ;
45978 PyObject * obj0 = 0 ;
45979 PyObject * obj1 = 0 ;
45980 char * kwnames[] = {
45981 (char *) "self",(char *) "window", NULL
45982 };
45983
45984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45986 if (!SWIG_IsOK(res1)) {
45987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45988 }
45989 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45991 if (!SWIG_IsOK(res2)) {
45992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45993 }
45994 arg2 = reinterpret_cast< wxWindow * >(argp2);
45995 {
45996 PyThreadState* __tstate = wxPyBeginAllowThreads();
45997 (arg1)->SetWindow(arg2);
45998 wxPyEndAllowThreads(__tstate);
45999 if (PyErr_Occurred()) SWIG_fail;
46000 }
46001 resultobj = SWIG_Py_Void();
46002 return resultobj;
46003 fail:
46004 return NULL;
46005 }
46006
46007
46008 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46009 PyObject *resultobj = 0;
46010 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46011 wxSizer *result = 0 ;
46012 void *argp1 = 0 ;
46013 int res1 = 0 ;
46014 PyObject *swig_obj[1] ;
46015
46016 if (!args) SWIG_fail;
46017 swig_obj[0] = args;
46018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46019 if (!SWIG_IsOK(res1)) {
46020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46021 }
46022 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46023 {
46024 PyThreadState* __tstate = wxPyBeginAllowThreads();
46025 result = (wxSizer *)(arg1)->GetSizer();
46026 wxPyEndAllowThreads(__tstate);
46027 if (PyErr_Occurred()) SWIG_fail;
46028 }
46029 {
46030 resultobj = wxPyMake_wxObject(result, (bool)0);
46031 }
46032 return resultobj;
46033 fail:
46034 return NULL;
46035 }
46036
46037
46038 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46039 PyObject *resultobj = 0;
46040 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46041 wxSizer *arg2 = (wxSizer *) 0 ;
46042 void *argp1 = 0 ;
46043 int res1 = 0 ;
46044 int res2 = 0 ;
46045 PyObject * obj0 = 0 ;
46046 PyObject * obj1 = 0 ;
46047 char * kwnames[] = {
46048 (char *) "self",(char *) "sizer", NULL
46049 };
46050
46051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46053 if (!SWIG_IsOK(res1)) {
46054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46055 }
46056 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46057 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46058 if (!SWIG_IsOK(res2)) {
46059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46060 }
46061 {
46062 PyThreadState* __tstate = wxPyBeginAllowThreads();
46063 (arg1)->SetSizer(arg2);
46064 wxPyEndAllowThreads(__tstate);
46065 if (PyErr_Occurred()) SWIG_fail;
46066 }
46067 resultobj = SWIG_Py_Void();
46068 return resultobj;
46069 fail:
46070 return NULL;
46071 }
46072
46073
46074 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46075 PyObject *resultobj = 0;
46076 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46077 wxSize *result = 0 ;
46078 void *argp1 = 0 ;
46079 int res1 = 0 ;
46080 PyObject *swig_obj[1] ;
46081
46082 if (!args) SWIG_fail;
46083 swig_obj[0] = args;
46084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46085 if (!SWIG_IsOK(res1)) {
46086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46087 }
46088 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46089 {
46090 PyThreadState* __tstate = wxPyBeginAllowThreads();
46091 {
46092 wxSize const &_result_ref = (arg1)->GetSpacer();
46093 result = (wxSize *) &_result_ref;
46094 }
46095 wxPyEndAllowThreads(__tstate);
46096 if (PyErr_Occurred()) SWIG_fail;
46097 }
46098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46099 return resultobj;
46100 fail:
46101 return NULL;
46102 }
46103
46104
46105 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46106 PyObject *resultobj = 0;
46107 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46108 wxSize *arg2 = 0 ;
46109 void *argp1 = 0 ;
46110 int res1 = 0 ;
46111 wxSize temp2 ;
46112 PyObject * obj0 = 0 ;
46113 PyObject * obj1 = 0 ;
46114 char * kwnames[] = {
46115 (char *) "self",(char *) "size", NULL
46116 };
46117
46118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46120 if (!SWIG_IsOK(res1)) {
46121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46122 }
46123 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46124 {
46125 arg2 = &temp2;
46126 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46127 }
46128 {
46129 PyThreadState* __tstate = wxPyBeginAllowThreads();
46130 (arg1)->SetSpacer((wxSize const &)*arg2);
46131 wxPyEndAllowThreads(__tstate);
46132 if (PyErr_Occurred()) SWIG_fail;
46133 }
46134 resultobj = SWIG_Py_Void();
46135 return resultobj;
46136 fail:
46137 return NULL;
46138 }
46139
46140
46141 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46142 PyObject *resultobj = 0;
46143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46144 bool arg2 ;
46145 void *argp1 = 0 ;
46146 int res1 = 0 ;
46147 bool val2 ;
46148 int ecode2 = 0 ;
46149 PyObject * obj0 = 0 ;
46150 PyObject * obj1 = 0 ;
46151 char * kwnames[] = {
46152 (char *) "self",(char *) "show", NULL
46153 };
46154
46155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46157 if (!SWIG_IsOK(res1)) {
46158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46159 }
46160 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46161 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46162 if (!SWIG_IsOK(ecode2)) {
46163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46164 }
46165 arg2 = static_cast< bool >(val2);
46166 {
46167 PyThreadState* __tstate = wxPyBeginAllowThreads();
46168 (arg1)->Show(arg2);
46169 wxPyEndAllowThreads(__tstate);
46170 if (PyErr_Occurred()) SWIG_fail;
46171 }
46172 resultobj = SWIG_Py_Void();
46173 return resultobj;
46174 fail:
46175 return NULL;
46176 }
46177
46178
46179 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46180 PyObject *resultobj = 0;
46181 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46182 bool result;
46183 void *argp1 = 0 ;
46184 int res1 = 0 ;
46185 PyObject *swig_obj[1] ;
46186
46187 if (!args) SWIG_fail;
46188 swig_obj[0] = args;
46189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46190 if (!SWIG_IsOK(res1)) {
46191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46192 }
46193 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46194 {
46195 PyThreadState* __tstate = wxPyBeginAllowThreads();
46196 result = (bool)(arg1)->IsShown();
46197 wxPyEndAllowThreads(__tstate);
46198 if (PyErr_Occurred()) SWIG_fail;
46199 }
46200 {
46201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46202 }
46203 return resultobj;
46204 fail:
46205 return NULL;
46206 }
46207
46208
46209 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46210 PyObject *resultobj = 0;
46211 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46212 wxPoint result;
46213 void *argp1 = 0 ;
46214 int res1 = 0 ;
46215 PyObject *swig_obj[1] ;
46216
46217 if (!args) SWIG_fail;
46218 swig_obj[0] = args;
46219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46220 if (!SWIG_IsOK(res1)) {
46221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46222 }
46223 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46224 {
46225 PyThreadState* __tstate = wxPyBeginAllowThreads();
46226 result = (arg1)->GetPosition();
46227 wxPyEndAllowThreads(__tstate);
46228 if (PyErr_Occurred()) SWIG_fail;
46229 }
46230 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46231 return resultobj;
46232 fail:
46233 return NULL;
46234 }
46235
46236
46237 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46238 PyObject *resultobj = 0;
46239 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46240 PyObject *result = 0 ;
46241 void *argp1 = 0 ;
46242 int res1 = 0 ;
46243 PyObject *swig_obj[1] ;
46244
46245 if (!args) SWIG_fail;
46246 swig_obj[0] = args;
46247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46248 if (!SWIG_IsOK(res1)) {
46249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46250 }
46251 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46252 {
46253 PyThreadState* __tstate = wxPyBeginAllowThreads();
46254 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46255 wxPyEndAllowThreads(__tstate);
46256 if (PyErr_Occurred()) SWIG_fail;
46257 }
46258 resultobj = result;
46259 return resultobj;
46260 fail:
46261 return NULL;
46262 }
46263
46264
46265 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46266 PyObject *resultobj = 0;
46267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46268 PyObject *arg2 = (PyObject *) 0 ;
46269 void *argp1 = 0 ;
46270 int res1 = 0 ;
46271 PyObject * obj0 = 0 ;
46272 PyObject * obj1 = 0 ;
46273 char * kwnames[] = {
46274 (char *) "self",(char *) "userData", NULL
46275 };
46276
46277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46279 if (!SWIG_IsOK(res1)) {
46280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46281 }
46282 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46283 arg2 = obj1;
46284 {
46285 PyThreadState* __tstate = wxPyBeginAllowThreads();
46286 wxSizerItem_SetUserData(arg1,arg2);
46287 wxPyEndAllowThreads(__tstate);
46288 if (PyErr_Occurred()) SWIG_fail;
46289 }
46290 resultobj = SWIG_Py_Void();
46291 return resultobj;
46292 fail:
46293 return NULL;
46294 }
46295
46296
46297 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46298 PyObject *obj;
46299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46300 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46301 return SWIG_Py_Void();
46302 }
46303
46304 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46305 return SWIG_Python_InitShadowInstance(args);
46306 }
46307
46308 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46309 PyObject *resultobj = 0;
46310 wxSizer *arg1 = (wxSizer *) 0 ;
46311 void *argp1 = 0 ;
46312 int res1 = 0 ;
46313 PyObject *swig_obj[1] ;
46314
46315 if (!args) SWIG_fail;
46316 swig_obj[0] = args;
46317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46318 if (!SWIG_IsOK(res1)) {
46319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46320 }
46321 arg1 = reinterpret_cast< wxSizer * >(argp1);
46322 {
46323 PyThreadState* __tstate = wxPyBeginAllowThreads();
46324 delete arg1;
46325
46326 wxPyEndAllowThreads(__tstate);
46327 if (PyErr_Occurred()) SWIG_fail;
46328 }
46329 resultobj = SWIG_Py_Void();
46330 return resultobj;
46331 fail:
46332 return NULL;
46333 }
46334
46335
46336 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46337 PyObject *resultobj = 0;
46338 wxSizer *arg1 = (wxSizer *) 0 ;
46339 PyObject *arg2 = (PyObject *) 0 ;
46340 void *argp1 = 0 ;
46341 int res1 = 0 ;
46342 PyObject * obj0 = 0 ;
46343 PyObject * obj1 = 0 ;
46344 char * kwnames[] = {
46345 (char *) "self",(char *) "_self", NULL
46346 };
46347
46348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46350 if (!SWIG_IsOK(res1)) {
46351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46352 }
46353 arg1 = reinterpret_cast< wxSizer * >(argp1);
46354 arg2 = obj1;
46355 {
46356 PyThreadState* __tstate = wxPyBeginAllowThreads();
46357 wxSizer__setOORInfo(arg1,arg2);
46358 wxPyEndAllowThreads(__tstate);
46359 if (PyErr_Occurred()) SWIG_fail;
46360 }
46361 resultobj = SWIG_Py_Void();
46362 return resultobj;
46363 fail:
46364 return NULL;
46365 }
46366
46367
46368 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46369 PyObject *resultobj = 0;
46370 wxSizer *arg1 = (wxSizer *) 0 ;
46371 PyObject *arg2 = (PyObject *) 0 ;
46372 int arg3 = (int) 0 ;
46373 int arg4 = (int) 0 ;
46374 int arg5 = (int) 0 ;
46375 PyObject *arg6 = (PyObject *) NULL ;
46376 wxSizerItem *result = 0 ;
46377 void *argp1 = 0 ;
46378 int res1 = 0 ;
46379 int val3 ;
46380 int ecode3 = 0 ;
46381 int val4 ;
46382 int ecode4 = 0 ;
46383 int val5 ;
46384 int ecode5 = 0 ;
46385 PyObject * obj0 = 0 ;
46386 PyObject * obj1 = 0 ;
46387 PyObject * obj2 = 0 ;
46388 PyObject * obj3 = 0 ;
46389 PyObject * obj4 = 0 ;
46390 PyObject * obj5 = 0 ;
46391 char * kwnames[] = {
46392 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46393 };
46394
46395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46397 if (!SWIG_IsOK(res1)) {
46398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46399 }
46400 arg1 = reinterpret_cast< wxSizer * >(argp1);
46401 arg2 = obj1;
46402 if (obj2) {
46403 ecode3 = SWIG_AsVal_int(obj2, &val3);
46404 if (!SWIG_IsOK(ecode3)) {
46405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46406 }
46407 arg3 = static_cast< int >(val3);
46408 }
46409 if (obj3) {
46410 ecode4 = SWIG_AsVal_int(obj3, &val4);
46411 if (!SWIG_IsOK(ecode4)) {
46412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46413 }
46414 arg4 = static_cast< int >(val4);
46415 }
46416 if (obj4) {
46417 ecode5 = SWIG_AsVal_int(obj4, &val5);
46418 if (!SWIG_IsOK(ecode5)) {
46419 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46420 }
46421 arg5 = static_cast< int >(val5);
46422 }
46423 if (obj5) {
46424 arg6 = obj5;
46425 }
46426 {
46427 PyThreadState* __tstate = wxPyBeginAllowThreads();
46428 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46429 wxPyEndAllowThreads(__tstate);
46430 if (PyErr_Occurred()) SWIG_fail;
46431 }
46432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46433 return resultobj;
46434 fail:
46435 return NULL;
46436 }
46437
46438
46439 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46440 PyObject *resultobj = 0;
46441 wxSizer *arg1 = (wxSizer *) 0 ;
46442 int arg2 ;
46443 PyObject *arg3 = (PyObject *) 0 ;
46444 int arg4 = (int) 0 ;
46445 int arg5 = (int) 0 ;
46446 int arg6 = (int) 0 ;
46447 PyObject *arg7 = (PyObject *) NULL ;
46448 wxSizerItem *result = 0 ;
46449 void *argp1 = 0 ;
46450 int res1 = 0 ;
46451 int val2 ;
46452 int ecode2 = 0 ;
46453 int val4 ;
46454 int ecode4 = 0 ;
46455 int val5 ;
46456 int ecode5 = 0 ;
46457 int val6 ;
46458 int ecode6 = 0 ;
46459 PyObject * obj0 = 0 ;
46460 PyObject * obj1 = 0 ;
46461 PyObject * obj2 = 0 ;
46462 PyObject * obj3 = 0 ;
46463 PyObject * obj4 = 0 ;
46464 PyObject * obj5 = 0 ;
46465 PyObject * obj6 = 0 ;
46466 char * kwnames[] = {
46467 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46468 };
46469
46470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46472 if (!SWIG_IsOK(res1)) {
46473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46474 }
46475 arg1 = reinterpret_cast< wxSizer * >(argp1);
46476 ecode2 = SWIG_AsVal_int(obj1, &val2);
46477 if (!SWIG_IsOK(ecode2)) {
46478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46479 }
46480 arg2 = static_cast< int >(val2);
46481 arg3 = obj2;
46482 if (obj3) {
46483 ecode4 = SWIG_AsVal_int(obj3, &val4);
46484 if (!SWIG_IsOK(ecode4)) {
46485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46486 }
46487 arg4 = static_cast< int >(val4);
46488 }
46489 if (obj4) {
46490 ecode5 = SWIG_AsVal_int(obj4, &val5);
46491 if (!SWIG_IsOK(ecode5)) {
46492 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46493 }
46494 arg5 = static_cast< int >(val5);
46495 }
46496 if (obj5) {
46497 ecode6 = SWIG_AsVal_int(obj5, &val6);
46498 if (!SWIG_IsOK(ecode6)) {
46499 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46500 }
46501 arg6 = static_cast< int >(val6);
46502 }
46503 if (obj6) {
46504 arg7 = obj6;
46505 }
46506 {
46507 PyThreadState* __tstate = wxPyBeginAllowThreads();
46508 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46509 wxPyEndAllowThreads(__tstate);
46510 if (PyErr_Occurred()) SWIG_fail;
46511 }
46512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46513 return resultobj;
46514 fail:
46515 return NULL;
46516 }
46517
46518
46519 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46520 PyObject *resultobj = 0;
46521 wxSizer *arg1 = (wxSizer *) 0 ;
46522 PyObject *arg2 = (PyObject *) 0 ;
46523 int arg3 = (int) 0 ;
46524 int arg4 = (int) 0 ;
46525 int arg5 = (int) 0 ;
46526 PyObject *arg6 = (PyObject *) NULL ;
46527 wxSizerItem *result = 0 ;
46528 void *argp1 = 0 ;
46529 int res1 = 0 ;
46530 int val3 ;
46531 int ecode3 = 0 ;
46532 int val4 ;
46533 int ecode4 = 0 ;
46534 int val5 ;
46535 int ecode5 = 0 ;
46536 PyObject * obj0 = 0 ;
46537 PyObject * obj1 = 0 ;
46538 PyObject * obj2 = 0 ;
46539 PyObject * obj3 = 0 ;
46540 PyObject * obj4 = 0 ;
46541 PyObject * obj5 = 0 ;
46542 char * kwnames[] = {
46543 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46544 };
46545
46546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46548 if (!SWIG_IsOK(res1)) {
46549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46550 }
46551 arg1 = reinterpret_cast< wxSizer * >(argp1);
46552 arg2 = obj1;
46553 if (obj2) {
46554 ecode3 = SWIG_AsVal_int(obj2, &val3);
46555 if (!SWIG_IsOK(ecode3)) {
46556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46557 }
46558 arg3 = static_cast< int >(val3);
46559 }
46560 if (obj3) {
46561 ecode4 = SWIG_AsVal_int(obj3, &val4);
46562 if (!SWIG_IsOK(ecode4)) {
46563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46564 }
46565 arg4 = static_cast< int >(val4);
46566 }
46567 if (obj4) {
46568 ecode5 = SWIG_AsVal_int(obj4, &val5);
46569 if (!SWIG_IsOK(ecode5)) {
46570 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46571 }
46572 arg5 = static_cast< int >(val5);
46573 }
46574 if (obj5) {
46575 arg6 = obj5;
46576 }
46577 {
46578 PyThreadState* __tstate = wxPyBeginAllowThreads();
46579 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46580 wxPyEndAllowThreads(__tstate);
46581 if (PyErr_Occurred()) SWIG_fail;
46582 }
46583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46584 return resultobj;
46585 fail:
46586 return NULL;
46587 }
46588
46589
46590 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46591 PyObject *resultobj = 0;
46592 wxSizer *arg1 = (wxSizer *) 0 ;
46593 PyObject *arg2 = (PyObject *) 0 ;
46594 bool result;
46595 void *argp1 = 0 ;
46596 int res1 = 0 ;
46597 PyObject * obj0 = 0 ;
46598 PyObject * obj1 = 0 ;
46599 char * kwnames[] = {
46600 (char *) "self",(char *) "item", NULL
46601 };
46602
46603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46605 if (!SWIG_IsOK(res1)) {
46606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46607 }
46608 arg1 = reinterpret_cast< wxSizer * >(argp1);
46609 arg2 = obj1;
46610 {
46611 PyThreadState* __tstate = wxPyBeginAllowThreads();
46612 result = (bool)wxSizer_Remove(arg1,arg2);
46613 wxPyEndAllowThreads(__tstate);
46614 if (PyErr_Occurred()) SWIG_fail;
46615 }
46616 {
46617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46618 }
46619 return resultobj;
46620 fail:
46621 return NULL;
46622 }
46623
46624
46625 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46626 PyObject *resultobj = 0;
46627 wxSizer *arg1 = (wxSizer *) 0 ;
46628 PyObject *arg2 = (PyObject *) 0 ;
46629 bool result;
46630 void *argp1 = 0 ;
46631 int res1 = 0 ;
46632 PyObject * obj0 = 0 ;
46633 PyObject * obj1 = 0 ;
46634 char * kwnames[] = {
46635 (char *) "self",(char *) "item", NULL
46636 };
46637
46638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46640 if (!SWIG_IsOK(res1)) {
46641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46642 }
46643 arg1 = reinterpret_cast< wxSizer * >(argp1);
46644 arg2 = obj1;
46645 {
46646 PyThreadState* __tstate = wxPyBeginAllowThreads();
46647 result = (bool)wxSizer_Detach(arg1,arg2);
46648 wxPyEndAllowThreads(__tstate);
46649 if (PyErr_Occurred()) SWIG_fail;
46650 }
46651 {
46652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46653 }
46654 return resultobj;
46655 fail:
46656 return NULL;
46657 }
46658
46659
46660 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46661 PyObject *resultobj = 0;
46662 wxSizer *arg1 = (wxSizer *) 0 ;
46663 PyObject *arg2 = (PyObject *) 0 ;
46664 wxSizerItem *result = 0 ;
46665 void *argp1 = 0 ;
46666 int res1 = 0 ;
46667 PyObject * obj0 = 0 ;
46668 PyObject * obj1 = 0 ;
46669 char * kwnames[] = {
46670 (char *) "self",(char *) "item", NULL
46671 };
46672
46673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46675 if (!SWIG_IsOK(res1)) {
46676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46677 }
46678 arg1 = reinterpret_cast< wxSizer * >(argp1);
46679 arg2 = obj1;
46680 {
46681 PyThreadState* __tstate = wxPyBeginAllowThreads();
46682 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46683 wxPyEndAllowThreads(__tstate);
46684 if (PyErr_Occurred()) SWIG_fail;
46685 }
46686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46687 return resultobj;
46688 fail:
46689 return NULL;
46690 }
46691
46692
46693 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46694 PyObject *resultobj = 0;
46695 wxSizer *arg1 = (wxSizer *) 0 ;
46696 PyObject *arg2 = (PyObject *) 0 ;
46697 wxSize *arg3 = 0 ;
46698 void *argp1 = 0 ;
46699 int res1 = 0 ;
46700 wxSize temp3 ;
46701 PyObject * obj0 = 0 ;
46702 PyObject * obj1 = 0 ;
46703 PyObject * obj2 = 0 ;
46704 char * kwnames[] = {
46705 (char *) "self",(char *) "item",(char *) "size", NULL
46706 };
46707
46708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46710 if (!SWIG_IsOK(res1)) {
46711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46712 }
46713 arg1 = reinterpret_cast< wxSizer * >(argp1);
46714 arg2 = obj1;
46715 {
46716 arg3 = &temp3;
46717 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46718 }
46719 {
46720 PyThreadState* __tstate = wxPyBeginAllowThreads();
46721 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46722 wxPyEndAllowThreads(__tstate);
46723 if (PyErr_Occurred()) SWIG_fail;
46724 }
46725 resultobj = SWIG_Py_Void();
46726 return resultobj;
46727 fail:
46728 return NULL;
46729 }
46730
46731
46732 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46733 PyObject *resultobj = 0;
46734 wxSizer *arg1 = (wxSizer *) 0 ;
46735 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46736 wxSizerItem *result = 0 ;
46737 void *argp1 = 0 ;
46738 int res1 = 0 ;
46739 int res2 = 0 ;
46740 PyObject * obj0 = 0 ;
46741 PyObject * obj1 = 0 ;
46742 char * kwnames[] = {
46743 (char *) "self",(char *) "item", NULL
46744 };
46745
46746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46748 if (!SWIG_IsOK(res1)) {
46749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46750 }
46751 arg1 = reinterpret_cast< wxSizer * >(argp1);
46752 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46753 if (!SWIG_IsOK(res2)) {
46754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46755 }
46756 {
46757 PyThreadState* __tstate = wxPyBeginAllowThreads();
46758 result = (wxSizerItem *)(arg1)->Add(arg2);
46759 wxPyEndAllowThreads(__tstate);
46760 if (PyErr_Occurred()) SWIG_fail;
46761 }
46762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46763 return resultobj;
46764 fail:
46765 return NULL;
46766 }
46767
46768
46769 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46770 PyObject *resultobj = 0;
46771 wxSizer *arg1 = (wxSizer *) 0 ;
46772 size_t arg2 ;
46773 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46774 wxSizerItem *result = 0 ;
46775 void *argp1 = 0 ;
46776 int res1 = 0 ;
46777 size_t val2 ;
46778 int ecode2 = 0 ;
46779 int res3 = 0 ;
46780 PyObject * obj0 = 0 ;
46781 PyObject * obj1 = 0 ;
46782 PyObject * obj2 = 0 ;
46783 char * kwnames[] = {
46784 (char *) "self",(char *) "index",(char *) "item", NULL
46785 };
46786
46787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46789 if (!SWIG_IsOK(res1)) {
46790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46791 }
46792 arg1 = reinterpret_cast< wxSizer * >(argp1);
46793 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46794 if (!SWIG_IsOK(ecode2)) {
46795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46796 }
46797 arg2 = static_cast< size_t >(val2);
46798 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46799 if (!SWIG_IsOK(res3)) {
46800 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46801 }
46802 {
46803 PyThreadState* __tstate = wxPyBeginAllowThreads();
46804 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46805 wxPyEndAllowThreads(__tstate);
46806 if (PyErr_Occurred()) SWIG_fail;
46807 }
46808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46809 return resultobj;
46810 fail:
46811 return NULL;
46812 }
46813
46814
46815 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46816 PyObject *resultobj = 0;
46817 wxSizer *arg1 = (wxSizer *) 0 ;
46818 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46819 wxSizerItem *result = 0 ;
46820 void *argp1 = 0 ;
46821 int res1 = 0 ;
46822 int res2 = 0 ;
46823 PyObject * obj0 = 0 ;
46824 PyObject * obj1 = 0 ;
46825 char * kwnames[] = {
46826 (char *) "self",(char *) "item", NULL
46827 };
46828
46829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46831 if (!SWIG_IsOK(res1)) {
46832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46833 }
46834 arg1 = reinterpret_cast< wxSizer * >(argp1);
46835 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46836 if (!SWIG_IsOK(res2)) {
46837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46838 }
46839 {
46840 PyThreadState* __tstate = wxPyBeginAllowThreads();
46841 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46842 wxPyEndAllowThreads(__tstate);
46843 if (PyErr_Occurred()) SWIG_fail;
46844 }
46845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46846 return resultobj;
46847 fail:
46848 return NULL;
46849 }
46850
46851
46852 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46853 PyObject *resultobj = 0;
46854 wxSizer *arg1 = (wxSizer *) 0 ;
46855 int arg2 ;
46856 int arg3 ;
46857 int arg4 ;
46858 int arg5 ;
46859 void *argp1 = 0 ;
46860 int res1 = 0 ;
46861 int val2 ;
46862 int ecode2 = 0 ;
46863 int val3 ;
46864 int ecode3 = 0 ;
46865 int val4 ;
46866 int ecode4 = 0 ;
46867 int val5 ;
46868 int ecode5 = 0 ;
46869 PyObject * obj0 = 0 ;
46870 PyObject * obj1 = 0 ;
46871 PyObject * obj2 = 0 ;
46872 PyObject * obj3 = 0 ;
46873 PyObject * obj4 = 0 ;
46874 char * kwnames[] = {
46875 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46876 };
46877
46878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46880 if (!SWIG_IsOK(res1)) {
46881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46882 }
46883 arg1 = reinterpret_cast< wxSizer * >(argp1);
46884 ecode2 = SWIG_AsVal_int(obj1, &val2);
46885 if (!SWIG_IsOK(ecode2)) {
46886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46887 }
46888 arg2 = static_cast< int >(val2);
46889 ecode3 = SWIG_AsVal_int(obj2, &val3);
46890 if (!SWIG_IsOK(ecode3)) {
46891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46892 }
46893 arg3 = static_cast< int >(val3);
46894 ecode4 = SWIG_AsVal_int(obj3, &val4);
46895 if (!SWIG_IsOK(ecode4)) {
46896 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46897 }
46898 arg4 = static_cast< int >(val4);
46899 ecode5 = SWIG_AsVal_int(obj4, &val5);
46900 if (!SWIG_IsOK(ecode5)) {
46901 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46902 }
46903 arg5 = static_cast< int >(val5);
46904 {
46905 PyThreadState* __tstate = wxPyBeginAllowThreads();
46906 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46907 wxPyEndAllowThreads(__tstate);
46908 if (PyErr_Occurred()) SWIG_fail;
46909 }
46910 resultobj = SWIG_Py_Void();
46911 return resultobj;
46912 fail:
46913 return NULL;
46914 }
46915
46916
46917 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46918 PyObject *resultobj = 0;
46919 wxSizer *arg1 = (wxSizer *) 0 ;
46920 wxSize *arg2 = 0 ;
46921 void *argp1 = 0 ;
46922 int res1 = 0 ;
46923 wxSize temp2 ;
46924 PyObject * obj0 = 0 ;
46925 PyObject * obj1 = 0 ;
46926 char * kwnames[] = {
46927 (char *) "self",(char *) "size", NULL
46928 };
46929
46930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46932 if (!SWIG_IsOK(res1)) {
46933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46934 }
46935 arg1 = reinterpret_cast< wxSizer * >(argp1);
46936 {
46937 arg2 = &temp2;
46938 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46939 }
46940 {
46941 PyThreadState* __tstate = wxPyBeginAllowThreads();
46942 (arg1)->SetMinSize((wxSize const &)*arg2);
46943 wxPyEndAllowThreads(__tstate);
46944 if (PyErr_Occurred()) SWIG_fail;
46945 }
46946 resultobj = SWIG_Py_Void();
46947 return resultobj;
46948 fail:
46949 return NULL;
46950 }
46951
46952
46953 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46954 PyObject *resultobj = 0;
46955 wxSizer *arg1 = (wxSizer *) 0 ;
46956 wxSize result;
46957 void *argp1 = 0 ;
46958 int res1 = 0 ;
46959 PyObject *swig_obj[1] ;
46960
46961 if (!args) SWIG_fail;
46962 swig_obj[0] = args;
46963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46964 if (!SWIG_IsOK(res1)) {
46965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46966 }
46967 arg1 = reinterpret_cast< wxSizer * >(argp1);
46968 {
46969 PyThreadState* __tstate = wxPyBeginAllowThreads();
46970 result = (arg1)->GetSize();
46971 wxPyEndAllowThreads(__tstate);
46972 if (PyErr_Occurred()) SWIG_fail;
46973 }
46974 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46975 return resultobj;
46976 fail:
46977 return NULL;
46978 }
46979
46980
46981 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46982 PyObject *resultobj = 0;
46983 wxSizer *arg1 = (wxSizer *) 0 ;
46984 wxPoint result;
46985 void *argp1 = 0 ;
46986 int res1 = 0 ;
46987 PyObject *swig_obj[1] ;
46988
46989 if (!args) SWIG_fail;
46990 swig_obj[0] = args;
46991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46992 if (!SWIG_IsOK(res1)) {
46993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46994 }
46995 arg1 = reinterpret_cast< wxSizer * >(argp1);
46996 {
46997 PyThreadState* __tstate = wxPyBeginAllowThreads();
46998 result = (arg1)->GetPosition();
46999 wxPyEndAllowThreads(__tstate);
47000 if (PyErr_Occurred()) SWIG_fail;
47001 }
47002 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47003 return resultobj;
47004 fail:
47005 return NULL;
47006 }
47007
47008
47009 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47010 PyObject *resultobj = 0;
47011 wxSizer *arg1 = (wxSizer *) 0 ;
47012 wxSize result;
47013 void *argp1 = 0 ;
47014 int res1 = 0 ;
47015 PyObject *swig_obj[1] ;
47016
47017 if (!args) SWIG_fail;
47018 swig_obj[0] = args;
47019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47020 if (!SWIG_IsOK(res1)) {
47021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47022 }
47023 arg1 = reinterpret_cast< wxSizer * >(argp1);
47024 {
47025 PyThreadState* __tstate = wxPyBeginAllowThreads();
47026 result = (arg1)->GetMinSize();
47027 wxPyEndAllowThreads(__tstate);
47028 if (PyErr_Occurred()) SWIG_fail;
47029 }
47030 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47031 return resultobj;
47032 fail:
47033 return NULL;
47034 }
47035
47036
47037 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47038 PyObject *resultobj = 0;
47039 wxSizer *arg1 = (wxSizer *) 0 ;
47040 void *argp1 = 0 ;
47041 int res1 = 0 ;
47042 PyObject *swig_obj[1] ;
47043
47044 if (!args) SWIG_fail;
47045 swig_obj[0] = args;
47046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47047 if (!SWIG_IsOK(res1)) {
47048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47049 }
47050 arg1 = reinterpret_cast< wxSizer * >(argp1);
47051 {
47052 PyThreadState* __tstate = wxPyBeginAllowThreads();
47053 (arg1)->RecalcSizes();
47054 wxPyEndAllowThreads(__tstate);
47055 if (PyErr_Occurred()) SWIG_fail;
47056 }
47057 resultobj = SWIG_Py_Void();
47058 return resultobj;
47059 fail:
47060 return NULL;
47061 }
47062
47063
47064 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47065 PyObject *resultobj = 0;
47066 wxSizer *arg1 = (wxSizer *) 0 ;
47067 wxSize result;
47068 void *argp1 = 0 ;
47069 int res1 = 0 ;
47070 PyObject *swig_obj[1] ;
47071
47072 if (!args) SWIG_fail;
47073 swig_obj[0] = args;
47074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47075 if (!SWIG_IsOK(res1)) {
47076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47077 }
47078 arg1 = reinterpret_cast< wxSizer * >(argp1);
47079 {
47080 PyThreadState* __tstate = wxPyBeginAllowThreads();
47081 result = (arg1)->CalcMin();
47082 wxPyEndAllowThreads(__tstate);
47083 if (PyErr_Occurred()) SWIG_fail;
47084 }
47085 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47086 return resultobj;
47087 fail:
47088 return NULL;
47089 }
47090
47091
47092 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47093 PyObject *resultobj = 0;
47094 wxSizer *arg1 = (wxSizer *) 0 ;
47095 void *argp1 = 0 ;
47096 int res1 = 0 ;
47097 PyObject *swig_obj[1] ;
47098
47099 if (!args) SWIG_fail;
47100 swig_obj[0] = args;
47101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47102 if (!SWIG_IsOK(res1)) {
47103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47104 }
47105 arg1 = reinterpret_cast< wxSizer * >(argp1);
47106 {
47107 PyThreadState* __tstate = wxPyBeginAllowThreads();
47108 (arg1)->Layout();
47109 wxPyEndAllowThreads(__tstate);
47110 if (PyErr_Occurred()) SWIG_fail;
47111 }
47112 resultobj = SWIG_Py_Void();
47113 return resultobj;
47114 fail:
47115 return NULL;
47116 }
47117
47118
47119 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47120 PyObject *resultobj = 0;
47121 wxSizer *arg1 = (wxSizer *) 0 ;
47122 wxWindow *arg2 = (wxWindow *) 0 ;
47123 wxSize result;
47124 void *argp1 = 0 ;
47125 int res1 = 0 ;
47126 void *argp2 = 0 ;
47127 int res2 = 0 ;
47128 PyObject * obj0 = 0 ;
47129 PyObject * obj1 = 0 ;
47130 char * kwnames[] = {
47131 (char *) "self",(char *) "window", NULL
47132 };
47133
47134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47136 if (!SWIG_IsOK(res1)) {
47137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47138 }
47139 arg1 = reinterpret_cast< wxSizer * >(argp1);
47140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47141 if (!SWIG_IsOK(res2)) {
47142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47143 }
47144 arg2 = reinterpret_cast< wxWindow * >(argp2);
47145 {
47146 PyThreadState* __tstate = wxPyBeginAllowThreads();
47147 result = (arg1)->Fit(arg2);
47148 wxPyEndAllowThreads(__tstate);
47149 if (PyErr_Occurred()) SWIG_fail;
47150 }
47151 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47152 return resultobj;
47153 fail:
47154 return NULL;
47155 }
47156
47157
47158 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47159 PyObject *resultobj = 0;
47160 wxSizer *arg1 = (wxSizer *) 0 ;
47161 wxWindow *arg2 = (wxWindow *) 0 ;
47162 void *argp1 = 0 ;
47163 int res1 = 0 ;
47164 void *argp2 = 0 ;
47165 int res2 = 0 ;
47166 PyObject * obj0 = 0 ;
47167 PyObject * obj1 = 0 ;
47168 char * kwnames[] = {
47169 (char *) "self",(char *) "window", NULL
47170 };
47171
47172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47174 if (!SWIG_IsOK(res1)) {
47175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47176 }
47177 arg1 = reinterpret_cast< wxSizer * >(argp1);
47178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47179 if (!SWIG_IsOK(res2)) {
47180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47181 }
47182 arg2 = reinterpret_cast< wxWindow * >(argp2);
47183 {
47184 PyThreadState* __tstate = wxPyBeginAllowThreads();
47185 (arg1)->FitInside(arg2);
47186 wxPyEndAllowThreads(__tstate);
47187 if (PyErr_Occurred()) SWIG_fail;
47188 }
47189 resultobj = SWIG_Py_Void();
47190 return resultobj;
47191 fail:
47192 return NULL;
47193 }
47194
47195
47196 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47197 PyObject *resultobj = 0;
47198 wxSizer *arg1 = (wxSizer *) 0 ;
47199 wxWindow *arg2 = (wxWindow *) 0 ;
47200 void *argp1 = 0 ;
47201 int res1 = 0 ;
47202 void *argp2 = 0 ;
47203 int res2 = 0 ;
47204 PyObject * obj0 = 0 ;
47205 PyObject * obj1 = 0 ;
47206 char * kwnames[] = {
47207 (char *) "self",(char *) "window", NULL
47208 };
47209
47210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47212 if (!SWIG_IsOK(res1)) {
47213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47214 }
47215 arg1 = reinterpret_cast< wxSizer * >(argp1);
47216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47217 if (!SWIG_IsOK(res2)) {
47218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47219 }
47220 arg2 = reinterpret_cast< wxWindow * >(argp2);
47221 {
47222 PyThreadState* __tstate = wxPyBeginAllowThreads();
47223 (arg1)->SetSizeHints(arg2);
47224 wxPyEndAllowThreads(__tstate);
47225 if (PyErr_Occurred()) SWIG_fail;
47226 }
47227 resultobj = SWIG_Py_Void();
47228 return resultobj;
47229 fail:
47230 return NULL;
47231 }
47232
47233
47234 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47235 PyObject *resultobj = 0;
47236 wxSizer *arg1 = (wxSizer *) 0 ;
47237 wxWindow *arg2 = (wxWindow *) 0 ;
47238 void *argp1 = 0 ;
47239 int res1 = 0 ;
47240 void *argp2 = 0 ;
47241 int res2 = 0 ;
47242 PyObject * obj0 = 0 ;
47243 PyObject * obj1 = 0 ;
47244 char * kwnames[] = {
47245 (char *) "self",(char *) "window", NULL
47246 };
47247
47248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47250 if (!SWIG_IsOK(res1)) {
47251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47252 }
47253 arg1 = reinterpret_cast< wxSizer * >(argp1);
47254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47255 if (!SWIG_IsOK(res2)) {
47256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47257 }
47258 arg2 = reinterpret_cast< wxWindow * >(argp2);
47259 {
47260 PyThreadState* __tstate = wxPyBeginAllowThreads();
47261 (arg1)->SetVirtualSizeHints(arg2);
47262 wxPyEndAllowThreads(__tstate);
47263 if (PyErr_Occurred()) SWIG_fail;
47264 }
47265 resultobj = SWIG_Py_Void();
47266 return resultobj;
47267 fail:
47268 return NULL;
47269 }
47270
47271
47272 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47273 PyObject *resultobj = 0;
47274 wxSizer *arg1 = (wxSizer *) 0 ;
47275 bool arg2 = (bool) false ;
47276 void *argp1 = 0 ;
47277 int res1 = 0 ;
47278 bool val2 ;
47279 int ecode2 = 0 ;
47280 PyObject * obj0 = 0 ;
47281 PyObject * obj1 = 0 ;
47282 char * kwnames[] = {
47283 (char *) "self",(char *) "deleteWindows", NULL
47284 };
47285
47286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47288 if (!SWIG_IsOK(res1)) {
47289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47290 }
47291 arg1 = reinterpret_cast< wxSizer * >(argp1);
47292 if (obj1) {
47293 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47294 if (!SWIG_IsOK(ecode2)) {
47295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47296 }
47297 arg2 = static_cast< bool >(val2);
47298 }
47299 {
47300 PyThreadState* __tstate = wxPyBeginAllowThreads();
47301 (arg1)->Clear(arg2);
47302 wxPyEndAllowThreads(__tstate);
47303 if (PyErr_Occurred()) SWIG_fail;
47304 }
47305 resultobj = SWIG_Py_Void();
47306 return resultobj;
47307 fail:
47308 return NULL;
47309 }
47310
47311
47312 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47313 PyObject *resultobj = 0;
47314 wxSizer *arg1 = (wxSizer *) 0 ;
47315 void *argp1 = 0 ;
47316 int res1 = 0 ;
47317 PyObject *swig_obj[1] ;
47318
47319 if (!args) SWIG_fail;
47320 swig_obj[0] = args;
47321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47322 if (!SWIG_IsOK(res1)) {
47323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47324 }
47325 arg1 = reinterpret_cast< wxSizer * >(argp1);
47326 {
47327 PyThreadState* __tstate = wxPyBeginAllowThreads();
47328 (arg1)->DeleteWindows();
47329 wxPyEndAllowThreads(__tstate);
47330 if (PyErr_Occurred()) SWIG_fail;
47331 }
47332 resultobj = SWIG_Py_Void();
47333 return resultobj;
47334 fail:
47335 return NULL;
47336 }
47337
47338
47339 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47340 PyObject *resultobj = 0;
47341 wxSizer *arg1 = (wxSizer *) 0 ;
47342 PyObject *result = 0 ;
47343 void *argp1 = 0 ;
47344 int res1 = 0 ;
47345 PyObject *swig_obj[1] ;
47346
47347 if (!args) SWIG_fail;
47348 swig_obj[0] = args;
47349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47350 if (!SWIG_IsOK(res1)) {
47351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47352 }
47353 arg1 = reinterpret_cast< wxSizer * >(argp1);
47354 {
47355 PyThreadState* __tstate = wxPyBeginAllowThreads();
47356 result = (PyObject *)wxSizer_GetChildren(arg1);
47357 wxPyEndAllowThreads(__tstate);
47358 if (PyErr_Occurred()) SWIG_fail;
47359 }
47360 resultobj = result;
47361 return resultobj;
47362 fail:
47363 return NULL;
47364 }
47365
47366
47367 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47368 PyObject *resultobj = 0;
47369 wxSizer *arg1 = (wxSizer *) 0 ;
47370 PyObject *arg2 = (PyObject *) 0 ;
47371 bool arg3 = (bool) true ;
47372 bool arg4 = (bool) false ;
47373 bool result;
47374 void *argp1 = 0 ;
47375 int res1 = 0 ;
47376 bool val3 ;
47377 int ecode3 = 0 ;
47378 bool val4 ;
47379 int ecode4 = 0 ;
47380 PyObject * obj0 = 0 ;
47381 PyObject * obj1 = 0 ;
47382 PyObject * obj2 = 0 ;
47383 PyObject * obj3 = 0 ;
47384 char * kwnames[] = {
47385 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47386 };
47387
47388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47390 if (!SWIG_IsOK(res1)) {
47391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47392 }
47393 arg1 = reinterpret_cast< wxSizer * >(argp1);
47394 arg2 = obj1;
47395 if (obj2) {
47396 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47397 if (!SWIG_IsOK(ecode3)) {
47398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47399 }
47400 arg3 = static_cast< bool >(val3);
47401 }
47402 if (obj3) {
47403 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47404 if (!SWIG_IsOK(ecode4)) {
47405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47406 }
47407 arg4 = static_cast< bool >(val4);
47408 }
47409 {
47410 PyThreadState* __tstate = wxPyBeginAllowThreads();
47411 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47412 wxPyEndAllowThreads(__tstate);
47413 if (PyErr_Occurred()) SWIG_fail;
47414 }
47415 {
47416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47417 }
47418 return resultobj;
47419 fail:
47420 return NULL;
47421 }
47422
47423
47424 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47425 PyObject *resultobj = 0;
47426 wxSizer *arg1 = (wxSizer *) 0 ;
47427 PyObject *arg2 = (PyObject *) 0 ;
47428 bool result;
47429 void *argp1 = 0 ;
47430 int res1 = 0 ;
47431 PyObject * obj0 = 0 ;
47432 PyObject * obj1 = 0 ;
47433 char * kwnames[] = {
47434 (char *) "self",(char *) "item", NULL
47435 };
47436
47437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47439 if (!SWIG_IsOK(res1)) {
47440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47441 }
47442 arg1 = reinterpret_cast< wxSizer * >(argp1);
47443 arg2 = obj1;
47444 {
47445 PyThreadState* __tstate = wxPyBeginAllowThreads();
47446 result = (bool)wxSizer_IsShown(arg1,arg2);
47447 wxPyEndAllowThreads(__tstate);
47448 if (PyErr_Occurred()) SWIG_fail;
47449 }
47450 {
47451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47452 }
47453 return resultobj;
47454 fail:
47455 return NULL;
47456 }
47457
47458
47459 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47460 PyObject *resultobj = 0;
47461 wxSizer *arg1 = (wxSizer *) 0 ;
47462 bool arg2 ;
47463 void *argp1 = 0 ;
47464 int res1 = 0 ;
47465 bool val2 ;
47466 int ecode2 = 0 ;
47467 PyObject * obj0 = 0 ;
47468 PyObject * obj1 = 0 ;
47469 char * kwnames[] = {
47470 (char *) "self",(char *) "show", NULL
47471 };
47472
47473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47475 if (!SWIG_IsOK(res1)) {
47476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47477 }
47478 arg1 = reinterpret_cast< wxSizer * >(argp1);
47479 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47480 if (!SWIG_IsOK(ecode2)) {
47481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47482 }
47483 arg2 = static_cast< bool >(val2);
47484 {
47485 PyThreadState* __tstate = wxPyBeginAllowThreads();
47486 (arg1)->ShowItems(arg2);
47487 wxPyEndAllowThreads(__tstate);
47488 if (PyErr_Occurred()) SWIG_fail;
47489 }
47490 resultobj = SWIG_Py_Void();
47491 return resultobj;
47492 fail:
47493 return NULL;
47494 }
47495
47496
47497 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47498 PyObject *obj;
47499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47500 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47501 return SWIG_Py_Void();
47502 }
47503
47504 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47505 PyObject *resultobj = 0;
47506 wxPySizer *result = 0 ;
47507
47508 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47509 {
47510 PyThreadState* __tstate = wxPyBeginAllowThreads();
47511 result = (wxPySizer *)new wxPySizer();
47512 wxPyEndAllowThreads(__tstate);
47513 if (PyErr_Occurred()) SWIG_fail;
47514 }
47515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47516 return resultobj;
47517 fail:
47518 return NULL;
47519 }
47520
47521
47522 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47523 PyObject *resultobj = 0;
47524 wxPySizer *arg1 = (wxPySizer *) 0 ;
47525 PyObject *arg2 = (PyObject *) 0 ;
47526 PyObject *arg3 = (PyObject *) 0 ;
47527 void *argp1 = 0 ;
47528 int res1 = 0 ;
47529 PyObject * obj0 = 0 ;
47530 PyObject * obj1 = 0 ;
47531 PyObject * obj2 = 0 ;
47532 char * kwnames[] = {
47533 (char *) "self",(char *) "self",(char *) "_class", NULL
47534 };
47535
47536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47538 if (!SWIG_IsOK(res1)) {
47539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47540 }
47541 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47542 arg2 = obj1;
47543 arg3 = obj2;
47544 {
47545 PyThreadState* __tstate = wxPyBeginAllowThreads();
47546 (arg1)->_setCallbackInfo(arg2,arg3);
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 *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47558 PyObject *obj;
47559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47560 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47561 return SWIG_Py_Void();
47562 }
47563
47564 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47565 return SWIG_Python_InitShadowInstance(args);
47566 }
47567
47568 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47569 PyObject *resultobj = 0;
47570 int arg1 = (int) wxHORIZONTAL ;
47571 wxBoxSizer *result = 0 ;
47572 int val1 ;
47573 int ecode1 = 0 ;
47574 PyObject * obj0 = 0 ;
47575 char * kwnames[] = {
47576 (char *) "orient", NULL
47577 };
47578
47579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47580 if (obj0) {
47581 ecode1 = SWIG_AsVal_int(obj0, &val1);
47582 if (!SWIG_IsOK(ecode1)) {
47583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47584 }
47585 arg1 = static_cast< int >(val1);
47586 }
47587 {
47588 PyThreadState* __tstate = wxPyBeginAllowThreads();
47589 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47590 wxPyEndAllowThreads(__tstate);
47591 if (PyErr_Occurred()) SWIG_fail;
47592 }
47593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47594 return resultobj;
47595 fail:
47596 return NULL;
47597 }
47598
47599
47600 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47601 PyObject *resultobj = 0;
47602 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47603 int result;
47604 void *argp1 = 0 ;
47605 int res1 = 0 ;
47606 PyObject *swig_obj[1] ;
47607
47608 if (!args) SWIG_fail;
47609 swig_obj[0] = args;
47610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47611 if (!SWIG_IsOK(res1)) {
47612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47613 }
47614 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47615 {
47616 PyThreadState* __tstate = wxPyBeginAllowThreads();
47617 result = (int)(arg1)->GetOrientation();
47618 wxPyEndAllowThreads(__tstate);
47619 if (PyErr_Occurred()) SWIG_fail;
47620 }
47621 resultobj = SWIG_From_int(static_cast< int >(result));
47622 return resultobj;
47623 fail:
47624 return NULL;
47625 }
47626
47627
47628 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47629 PyObject *resultobj = 0;
47630 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47631 int arg2 ;
47632 void *argp1 = 0 ;
47633 int res1 = 0 ;
47634 int val2 ;
47635 int ecode2 = 0 ;
47636 PyObject * obj0 = 0 ;
47637 PyObject * obj1 = 0 ;
47638 char * kwnames[] = {
47639 (char *) "self",(char *) "orient", NULL
47640 };
47641
47642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47644 if (!SWIG_IsOK(res1)) {
47645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47646 }
47647 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47648 ecode2 = SWIG_AsVal_int(obj1, &val2);
47649 if (!SWIG_IsOK(ecode2)) {
47650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47651 }
47652 arg2 = static_cast< int >(val2);
47653 {
47654 PyThreadState* __tstate = wxPyBeginAllowThreads();
47655 (arg1)->SetOrientation(arg2);
47656 wxPyEndAllowThreads(__tstate);
47657 if (PyErr_Occurred()) SWIG_fail;
47658 }
47659 resultobj = SWIG_Py_Void();
47660 return resultobj;
47661 fail:
47662 return NULL;
47663 }
47664
47665
47666 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47667 PyObject *obj;
47668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47669 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47670 return SWIG_Py_Void();
47671 }
47672
47673 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47674 return SWIG_Python_InitShadowInstance(args);
47675 }
47676
47677 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47678 PyObject *resultobj = 0;
47679 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47680 int arg2 = (int) wxHORIZONTAL ;
47681 wxStaticBoxSizer *result = 0 ;
47682 void *argp1 = 0 ;
47683 int res1 = 0 ;
47684 int val2 ;
47685 int ecode2 = 0 ;
47686 PyObject * obj0 = 0 ;
47687 PyObject * obj1 = 0 ;
47688 char * kwnames[] = {
47689 (char *) "box",(char *) "orient", NULL
47690 };
47691
47692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47694 if (!SWIG_IsOK(res1)) {
47695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47696 }
47697 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47698 if (obj1) {
47699 ecode2 = SWIG_AsVal_int(obj1, &val2);
47700 if (!SWIG_IsOK(ecode2)) {
47701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47702 }
47703 arg2 = static_cast< int >(val2);
47704 }
47705 {
47706 PyThreadState* __tstate = wxPyBeginAllowThreads();
47707 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47708 wxPyEndAllowThreads(__tstate);
47709 if (PyErr_Occurred()) SWIG_fail;
47710 }
47711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47712 return resultobj;
47713 fail:
47714 return NULL;
47715 }
47716
47717
47718 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47719 PyObject *resultobj = 0;
47720 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47721 wxStaticBox *result = 0 ;
47722 void *argp1 = 0 ;
47723 int res1 = 0 ;
47724 PyObject *swig_obj[1] ;
47725
47726 if (!args) SWIG_fail;
47727 swig_obj[0] = args;
47728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47729 if (!SWIG_IsOK(res1)) {
47730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47731 }
47732 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47733 {
47734 PyThreadState* __tstate = wxPyBeginAllowThreads();
47735 result = (wxStaticBox *)(arg1)->GetStaticBox();
47736 wxPyEndAllowThreads(__tstate);
47737 if (PyErr_Occurred()) SWIG_fail;
47738 }
47739 {
47740 resultobj = wxPyMake_wxObject(result, (bool)0);
47741 }
47742 return resultobj;
47743 fail:
47744 return NULL;
47745 }
47746
47747
47748 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47749 PyObject *obj;
47750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47751 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47752 return SWIG_Py_Void();
47753 }
47754
47755 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47756 return SWIG_Python_InitShadowInstance(args);
47757 }
47758
47759 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47760 PyObject *resultobj = 0;
47761 int arg1 = (int) 1 ;
47762 int arg2 = (int) 0 ;
47763 int arg3 = (int) 0 ;
47764 int arg4 = (int) 0 ;
47765 wxGridSizer *result = 0 ;
47766 int val1 ;
47767 int ecode1 = 0 ;
47768 int val2 ;
47769 int ecode2 = 0 ;
47770 int val3 ;
47771 int ecode3 = 0 ;
47772 int val4 ;
47773 int ecode4 = 0 ;
47774 PyObject * obj0 = 0 ;
47775 PyObject * obj1 = 0 ;
47776 PyObject * obj2 = 0 ;
47777 PyObject * obj3 = 0 ;
47778 char * kwnames[] = {
47779 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47780 };
47781
47782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47783 if (obj0) {
47784 ecode1 = SWIG_AsVal_int(obj0, &val1);
47785 if (!SWIG_IsOK(ecode1)) {
47786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47787 }
47788 arg1 = static_cast< int >(val1);
47789 }
47790 if (obj1) {
47791 ecode2 = SWIG_AsVal_int(obj1, &val2);
47792 if (!SWIG_IsOK(ecode2)) {
47793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47794 }
47795 arg2 = static_cast< int >(val2);
47796 }
47797 if (obj2) {
47798 ecode3 = SWIG_AsVal_int(obj2, &val3);
47799 if (!SWIG_IsOK(ecode3)) {
47800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47801 }
47802 arg3 = static_cast< int >(val3);
47803 }
47804 if (obj3) {
47805 ecode4 = SWIG_AsVal_int(obj3, &val4);
47806 if (!SWIG_IsOK(ecode4)) {
47807 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47808 }
47809 arg4 = static_cast< int >(val4);
47810 }
47811 {
47812 PyThreadState* __tstate = wxPyBeginAllowThreads();
47813 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47814 wxPyEndAllowThreads(__tstate);
47815 if (PyErr_Occurred()) SWIG_fail;
47816 }
47817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47818 return resultobj;
47819 fail:
47820 return NULL;
47821 }
47822
47823
47824 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47825 PyObject *resultobj = 0;
47826 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47827 int arg2 ;
47828 void *argp1 = 0 ;
47829 int res1 = 0 ;
47830 int val2 ;
47831 int ecode2 = 0 ;
47832 PyObject * obj0 = 0 ;
47833 PyObject * obj1 = 0 ;
47834 char * kwnames[] = {
47835 (char *) "self",(char *) "cols", NULL
47836 };
47837
47838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47840 if (!SWIG_IsOK(res1)) {
47841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47842 }
47843 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47844 ecode2 = SWIG_AsVal_int(obj1, &val2);
47845 if (!SWIG_IsOK(ecode2)) {
47846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47847 }
47848 arg2 = static_cast< int >(val2);
47849 {
47850 PyThreadState* __tstate = wxPyBeginAllowThreads();
47851 (arg1)->SetCols(arg2);
47852 wxPyEndAllowThreads(__tstate);
47853 if (PyErr_Occurred()) SWIG_fail;
47854 }
47855 resultobj = SWIG_Py_Void();
47856 return resultobj;
47857 fail:
47858 return NULL;
47859 }
47860
47861
47862 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47863 PyObject *resultobj = 0;
47864 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47865 int arg2 ;
47866 void *argp1 = 0 ;
47867 int res1 = 0 ;
47868 int val2 ;
47869 int ecode2 = 0 ;
47870 PyObject * obj0 = 0 ;
47871 PyObject * obj1 = 0 ;
47872 char * kwnames[] = {
47873 (char *) "self",(char *) "rows", NULL
47874 };
47875
47876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47878 if (!SWIG_IsOK(res1)) {
47879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47880 }
47881 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47882 ecode2 = SWIG_AsVal_int(obj1, &val2);
47883 if (!SWIG_IsOK(ecode2)) {
47884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47885 }
47886 arg2 = static_cast< int >(val2);
47887 {
47888 PyThreadState* __tstate = wxPyBeginAllowThreads();
47889 (arg1)->SetRows(arg2);
47890 wxPyEndAllowThreads(__tstate);
47891 if (PyErr_Occurred()) SWIG_fail;
47892 }
47893 resultobj = SWIG_Py_Void();
47894 return resultobj;
47895 fail:
47896 return NULL;
47897 }
47898
47899
47900 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47901 PyObject *resultobj = 0;
47902 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47903 int arg2 ;
47904 void *argp1 = 0 ;
47905 int res1 = 0 ;
47906 int val2 ;
47907 int ecode2 = 0 ;
47908 PyObject * obj0 = 0 ;
47909 PyObject * obj1 = 0 ;
47910 char * kwnames[] = {
47911 (char *) "self",(char *) "gap", NULL
47912 };
47913
47914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47916 if (!SWIG_IsOK(res1)) {
47917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47918 }
47919 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47920 ecode2 = SWIG_AsVal_int(obj1, &val2);
47921 if (!SWIG_IsOK(ecode2)) {
47922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47923 }
47924 arg2 = static_cast< int >(val2);
47925 {
47926 PyThreadState* __tstate = wxPyBeginAllowThreads();
47927 (arg1)->SetVGap(arg2);
47928 wxPyEndAllowThreads(__tstate);
47929 if (PyErr_Occurred()) SWIG_fail;
47930 }
47931 resultobj = SWIG_Py_Void();
47932 return resultobj;
47933 fail:
47934 return NULL;
47935 }
47936
47937
47938 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47939 PyObject *resultobj = 0;
47940 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47941 int arg2 ;
47942 void *argp1 = 0 ;
47943 int res1 = 0 ;
47944 int val2 ;
47945 int ecode2 = 0 ;
47946 PyObject * obj0 = 0 ;
47947 PyObject * obj1 = 0 ;
47948 char * kwnames[] = {
47949 (char *) "self",(char *) "gap", NULL
47950 };
47951
47952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47954 if (!SWIG_IsOK(res1)) {
47955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47956 }
47957 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47958 ecode2 = SWIG_AsVal_int(obj1, &val2);
47959 if (!SWIG_IsOK(ecode2)) {
47960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47961 }
47962 arg2 = static_cast< int >(val2);
47963 {
47964 PyThreadState* __tstate = wxPyBeginAllowThreads();
47965 (arg1)->SetHGap(arg2);
47966 wxPyEndAllowThreads(__tstate);
47967 if (PyErr_Occurred()) SWIG_fail;
47968 }
47969 resultobj = SWIG_Py_Void();
47970 return resultobj;
47971 fail:
47972 return NULL;
47973 }
47974
47975
47976 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47977 PyObject *resultobj = 0;
47978 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47979 int result;
47980 void *argp1 = 0 ;
47981 int res1 = 0 ;
47982 PyObject *swig_obj[1] ;
47983
47984 if (!args) SWIG_fail;
47985 swig_obj[0] = args;
47986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47987 if (!SWIG_IsOK(res1)) {
47988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47989 }
47990 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47991 {
47992 PyThreadState* __tstate = wxPyBeginAllowThreads();
47993 result = (int)(arg1)->GetCols();
47994 wxPyEndAllowThreads(__tstate);
47995 if (PyErr_Occurred()) SWIG_fail;
47996 }
47997 resultobj = SWIG_From_int(static_cast< int >(result));
47998 return resultobj;
47999 fail:
48000 return NULL;
48001 }
48002
48003
48004 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48005 PyObject *resultobj = 0;
48006 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48007 int result;
48008 void *argp1 = 0 ;
48009 int res1 = 0 ;
48010 PyObject *swig_obj[1] ;
48011
48012 if (!args) SWIG_fail;
48013 swig_obj[0] = args;
48014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48015 if (!SWIG_IsOK(res1)) {
48016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48017 }
48018 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48019 {
48020 PyThreadState* __tstate = wxPyBeginAllowThreads();
48021 result = (int)(arg1)->GetRows();
48022 wxPyEndAllowThreads(__tstate);
48023 if (PyErr_Occurred()) SWIG_fail;
48024 }
48025 resultobj = SWIG_From_int(static_cast< int >(result));
48026 return resultobj;
48027 fail:
48028 return NULL;
48029 }
48030
48031
48032 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48033 PyObject *resultobj = 0;
48034 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48035 int result;
48036 void *argp1 = 0 ;
48037 int res1 = 0 ;
48038 PyObject *swig_obj[1] ;
48039
48040 if (!args) SWIG_fail;
48041 swig_obj[0] = args;
48042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48043 if (!SWIG_IsOK(res1)) {
48044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48045 }
48046 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48047 {
48048 PyThreadState* __tstate = wxPyBeginAllowThreads();
48049 result = (int)(arg1)->GetVGap();
48050 wxPyEndAllowThreads(__tstate);
48051 if (PyErr_Occurred()) SWIG_fail;
48052 }
48053 resultobj = SWIG_From_int(static_cast< int >(result));
48054 return resultobj;
48055 fail:
48056 return NULL;
48057 }
48058
48059
48060 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48061 PyObject *resultobj = 0;
48062 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48063 int result;
48064 void *argp1 = 0 ;
48065 int res1 = 0 ;
48066 PyObject *swig_obj[1] ;
48067
48068 if (!args) SWIG_fail;
48069 swig_obj[0] = args;
48070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48071 if (!SWIG_IsOK(res1)) {
48072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48073 }
48074 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48075 {
48076 PyThreadState* __tstate = wxPyBeginAllowThreads();
48077 result = (int)(arg1)->GetHGap();
48078 wxPyEndAllowThreads(__tstate);
48079 if (PyErr_Occurred()) SWIG_fail;
48080 }
48081 resultobj = SWIG_From_int(static_cast< int >(result));
48082 return resultobj;
48083 fail:
48084 return NULL;
48085 }
48086
48087
48088 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48089 PyObject *obj;
48090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48091 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48092 return SWIG_Py_Void();
48093 }
48094
48095 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48096 return SWIG_Python_InitShadowInstance(args);
48097 }
48098
48099 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48100 PyObject *resultobj = 0;
48101 int arg1 = (int) 1 ;
48102 int arg2 = (int) 0 ;
48103 int arg3 = (int) 0 ;
48104 int arg4 = (int) 0 ;
48105 wxFlexGridSizer *result = 0 ;
48106 int val1 ;
48107 int ecode1 = 0 ;
48108 int val2 ;
48109 int ecode2 = 0 ;
48110 int val3 ;
48111 int ecode3 = 0 ;
48112 int val4 ;
48113 int ecode4 = 0 ;
48114 PyObject * obj0 = 0 ;
48115 PyObject * obj1 = 0 ;
48116 PyObject * obj2 = 0 ;
48117 PyObject * obj3 = 0 ;
48118 char * kwnames[] = {
48119 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48120 };
48121
48122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48123 if (obj0) {
48124 ecode1 = SWIG_AsVal_int(obj0, &val1);
48125 if (!SWIG_IsOK(ecode1)) {
48126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48127 }
48128 arg1 = static_cast< int >(val1);
48129 }
48130 if (obj1) {
48131 ecode2 = SWIG_AsVal_int(obj1, &val2);
48132 if (!SWIG_IsOK(ecode2)) {
48133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48134 }
48135 arg2 = static_cast< int >(val2);
48136 }
48137 if (obj2) {
48138 ecode3 = SWIG_AsVal_int(obj2, &val3);
48139 if (!SWIG_IsOK(ecode3)) {
48140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48141 }
48142 arg3 = static_cast< int >(val3);
48143 }
48144 if (obj3) {
48145 ecode4 = SWIG_AsVal_int(obj3, &val4);
48146 if (!SWIG_IsOK(ecode4)) {
48147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48148 }
48149 arg4 = static_cast< int >(val4);
48150 }
48151 {
48152 PyThreadState* __tstate = wxPyBeginAllowThreads();
48153 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48154 wxPyEndAllowThreads(__tstate);
48155 if (PyErr_Occurred()) SWIG_fail;
48156 }
48157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48158 return resultobj;
48159 fail:
48160 return NULL;
48161 }
48162
48163
48164 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48165 PyObject *resultobj = 0;
48166 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48167 size_t arg2 ;
48168 int arg3 = (int) 0 ;
48169 void *argp1 = 0 ;
48170 int res1 = 0 ;
48171 size_t val2 ;
48172 int ecode2 = 0 ;
48173 int val3 ;
48174 int ecode3 = 0 ;
48175 PyObject * obj0 = 0 ;
48176 PyObject * obj1 = 0 ;
48177 PyObject * obj2 = 0 ;
48178 char * kwnames[] = {
48179 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48180 };
48181
48182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48184 if (!SWIG_IsOK(res1)) {
48185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48186 }
48187 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48188 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48189 if (!SWIG_IsOK(ecode2)) {
48190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48191 }
48192 arg2 = static_cast< size_t >(val2);
48193 if (obj2) {
48194 ecode3 = SWIG_AsVal_int(obj2, &val3);
48195 if (!SWIG_IsOK(ecode3)) {
48196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48197 }
48198 arg3 = static_cast< int >(val3);
48199 }
48200 {
48201 PyThreadState* __tstate = wxPyBeginAllowThreads();
48202 (arg1)->AddGrowableRow(arg2,arg3);
48203 wxPyEndAllowThreads(__tstate);
48204 if (PyErr_Occurred()) SWIG_fail;
48205 }
48206 resultobj = SWIG_Py_Void();
48207 return resultobj;
48208 fail:
48209 return NULL;
48210 }
48211
48212
48213 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48214 PyObject *resultobj = 0;
48215 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48216 size_t arg2 ;
48217 void *argp1 = 0 ;
48218 int res1 = 0 ;
48219 size_t val2 ;
48220 int ecode2 = 0 ;
48221 PyObject * obj0 = 0 ;
48222 PyObject * obj1 = 0 ;
48223 char * kwnames[] = {
48224 (char *) "self",(char *) "idx", NULL
48225 };
48226
48227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48229 if (!SWIG_IsOK(res1)) {
48230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48231 }
48232 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48233 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48234 if (!SWIG_IsOK(ecode2)) {
48235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48236 }
48237 arg2 = static_cast< size_t >(val2);
48238 {
48239 PyThreadState* __tstate = wxPyBeginAllowThreads();
48240 (arg1)->RemoveGrowableRow(arg2);
48241 wxPyEndAllowThreads(__tstate);
48242 if (PyErr_Occurred()) SWIG_fail;
48243 }
48244 resultobj = SWIG_Py_Void();
48245 return resultobj;
48246 fail:
48247 return NULL;
48248 }
48249
48250
48251 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48252 PyObject *resultobj = 0;
48253 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48254 size_t arg2 ;
48255 int arg3 = (int) 0 ;
48256 void *argp1 = 0 ;
48257 int res1 = 0 ;
48258 size_t val2 ;
48259 int ecode2 = 0 ;
48260 int val3 ;
48261 int ecode3 = 0 ;
48262 PyObject * obj0 = 0 ;
48263 PyObject * obj1 = 0 ;
48264 PyObject * obj2 = 0 ;
48265 char * kwnames[] = {
48266 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48267 };
48268
48269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48271 if (!SWIG_IsOK(res1)) {
48272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48273 }
48274 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48275 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48276 if (!SWIG_IsOK(ecode2)) {
48277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48278 }
48279 arg2 = static_cast< size_t >(val2);
48280 if (obj2) {
48281 ecode3 = SWIG_AsVal_int(obj2, &val3);
48282 if (!SWIG_IsOK(ecode3)) {
48283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48284 }
48285 arg3 = static_cast< int >(val3);
48286 }
48287 {
48288 PyThreadState* __tstate = wxPyBeginAllowThreads();
48289 (arg1)->AddGrowableCol(arg2,arg3);
48290 wxPyEndAllowThreads(__tstate);
48291 if (PyErr_Occurred()) SWIG_fail;
48292 }
48293 resultobj = SWIG_Py_Void();
48294 return resultobj;
48295 fail:
48296 return NULL;
48297 }
48298
48299
48300 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48301 PyObject *resultobj = 0;
48302 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48303 size_t arg2 ;
48304 void *argp1 = 0 ;
48305 int res1 = 0 ;
48306 size_t val2 ;
48307 int ecode2 = 0 ;
48308 PyObject * obj0 = 0 ;
48309 PyObject * obj1 = 0 ;
48310 char * kwnames[] = {
48311 (char *) "self",(char *) "idx", NULL
48312 };
48313
48314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48316 if (!SWIG_IsOK(res1)) {
48317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48318 }
48319 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48320 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48321 if (!SWIG_IsOK(ecode2)) {
48322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48323 }
48324 arg2 = static_cast< size_t >(val2);
48325 {
48326 PyThreadState* __tstate = wxPyBeginAllowThreads();
48327 (arg1)->RemoveGrowableCol(arg2);
48328 wxPyEndAllowThreads(__tstate);
48329 if (PyErr_Occurred()) SWIG_fail;
48330 }
48331 resultobj = SWIG_Py_Void();
48332 return resultobj;
48333 fail:
48334 return NULL;
48335 }
48336
48337
48338 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48339 PyObject *resultobj = 0;
48340 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48341 int arg2 ;
48342 void *argp1 = 0 ;
48343 int res1 = 0 ;
48344 int val2 ;
48345 int ecode2 = 0 ;
48346 PyObject * obj0 = 0 ;
48347 PyObject * obj1 = 0 ;
48348 char * kwnames[] = {
48349 (char *) "self",(char *) "direction", NULL
48350 };
48351
48352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48354 if (!SWIG_IsOK(res1)) {
48355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48356 }
48357 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48358 ecode2 = SWIG_AsVal_int(obj1, &val2);
48359 if (!SWIG_IsOK(ecode2)) {
48360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48361 }
48362 arg2 = static_cast< int >(val2);
48363 {
48364 PyThreadState* __tstate = wxPyBeginAllowThreads();
48365 (arg1)->SetFlexibleDirection(arg2);
48366 wxPyEndAllowThreads(__tstate);
48367 if (PyErr_Occurred()) SWIG_fail;
48368 }
48369 resultobj = SWIG_Py_Void();
48370 return resultobj;
48371 fail:
48372 return NULL;
48373 }
48374
48375
48376 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48377 PyObject *resultobj = 0;
48378 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48379 int result;
48380 void *argp1 = 0 ;
48381 int res1 = 0 ;
48382 PyObject *swig_obj[1] ;
48383
48384 if (!args) SWIG_fail;
48385 swig_obj[0] = args;
48386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48387 if (!SWIG_IsOK(res1)) {
48388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48389 }
48390 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48391 {
48392 PyThreadState* __tstate = wxPyBeginAllowThreads();
48393 result = (int)(arg1)->GetFlexibleDirection();
48394 wxPyEndAllowThreads(__tstate);
48395 if (PyErr_Occurred()) SWIG_fail;
48396 }
48397 resultobj = SWIG_From_int(static_cast< int >(result));
48398 return resultobj;
48399 fail:
48400 return NULL;
48401 }
48402
48403
48404 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48405 PyObject *resultobj = 0;
48406 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48407 wxFlexSizerGrowMode arg2 ;
48408 void *argp1 = 0 ;
48409 int res1 = 0 ;
48410 int val2 ;
48411 int ecode2 = 0 ;
48412 PyObject * obj0 = 0 ;
48413 PyObject * obj1 = 0 ;
48414 char * kwnames[] = {
48415 (char *) "self",(char *) "mode", NULL
48416 };
48417
48418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48420 if (!SWIG_IsOK(res1)) {
48421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48422 }
48423 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48424 ecode2 = SWIG_AsVal_int(obj1, &val2);
48425 if (!SWIG_IsOK(ecode2)) {
48426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48427 }
48428 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48429 {
48430 PyThreadState* __tstate = wxPyBeginAllowThreads();
48431 (arg1)->SetNonFlexibleGrowMode(arg2);
48432 wxPyEndAllowThreads(__tstate);
48433 if (PyErr_Occurred()) SWIG_fail;
48434 }
48435 resultobj = SWIG_Py_Void();
48436 return resultobj;
48437 fail:
48438 return NULL;
48439 }
48440
48441
48442 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48443 PyObject *resultobj = 0;
48444 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48445 wxFlexSizerGrowMode result;
48446 void *argp1 = 0 ;
48447 int res1 = 0 ;
48448 PyObject *swig_obj[1] ;
48449
48450 if (!args) SWIG_fail;
48451 swig_obj[0] = args;
48452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48453 if (!SWIG_IsOK(res1)) {
48454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48455 }
48456 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48457 {
48458 PyThreadState* __tstate = wxPyBeginAllowThreads();
48459 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48460 wxPyEndAllowThreads(__tstate);
48461 if (PyErr_Occurred()) SWIG_fail;
48462 }
48463 resultobj = SWIG_From_int(static_cast< int >(result));
48464 return resultobj;
48465 fail:
48466 return NULL;
48467 }
48468
48469
48470 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48471 PyObject *resultobj = 0;
48472 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48473 wxArrayInt *result = 0 ;
48474 void *argp1 = 0 ;
48475 int res1 = 0 ;
48476 PyObject *swig_obj[1] ;
48477
48478 if (!args) SWIG_fail;
48479 swig_obj[0] = args;
48480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48481 if (!SWIG_IsOK(res1)) {
48482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48483 }
48484 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48485 {
48486 PyThreadState* __tstate = wxPyBeginAllowThreads();
48487 {
48488 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48489 result = (wxArrayInt *) &_result_ref;
48490 }
48491 wxPyEndAllowThreads(__tstate);
48492 if (PyErr_Occurred()) SWIG_fail;
48493 }
48494 {
48495 resultobj = PyList_New(0);
48496 size_t idx;
48497 for (idx = 0; idx < result->GetCount(); idx += 1) {
48498 PyObject* val = PyInt_FromLong( result->Item(idx) );
48499 PyList_Append(resultobj, val);
48500 Py_DECREF(val);
48501 }
48502 }
48503 return resultobj;
48504 fail:
48505 return NULL;
48506 }
48507
48508
48509 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48510 PyObject *resultobj = 0;
48511 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48512 wxArrayInt *result = 0 ;
48513 void *argp1 = 0 ;
48514 int res1 = 0 ;
48515 PyObject *swig_obj[1] ;
48516
48517 if (!args) SWIG_fail;
48518 swig_obj[0] = args;
48519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48520 if (!SWIG_IsOK(res1)) {
48521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48522 }
48523 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48524 {
48525 PyThreadState* __tstate = wxPyBeginAllowThreads();
48526 {
48527 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48528 result = (wxArrayInt *) &_result_ref;
48529 }
48530 wxPyEndAllowThreads(__tstate);
48531 if (PyErr_Occurred()) SWIG_fail;
48532 }
48533 {
48534 resultobj = PyList_New(0);
48535 size_t idx;
48536 for (idx = 0; idx < result->GetCount(); idx += 1) {
48537 PyObject* val = PyInt_FromLong( result->Item(idx) );
48538 PyList_Append(resultobj, val);
48539 Py_DECREF(val);
48540 }
48541 }
48542 return resultobj;
48543 fail:
48544 return NULL;
48545 }
48546
48547
48548 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48549 PyObject *obj;
48550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48551 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48552 return SWIG_Py_Void();
48553 }
48554
48555 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48556 return SWIG_Python_InitShadowInstance(args);
48557 }
48558
48559 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48560 PyObject *resultobj = 0;
48561 wxStdDialogButtonSizer *result = 0 ;
48562
48563 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48564 {
48565 PyThreadState* __tstate = wxPyBeginAllowThreads();
48566 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48567 wxPyEndAllowThreads(__tstate);
48568 if (PyErr_Occurred()) SWIG_fail;
48569 }
48570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48571 return resultobj;
48572 fail:
48573 return NULL;
48574 }
48575
48576
48577 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48578 PyObject *resultobj = 0;
48579 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48580 wxButton *arg2 = (wxButton *) 0 ;
48581 void *argp1 = 0 ;
48582 int res1 = 0 ;
48583 void *argp2 = 0 ;
48584 int res2 = 0 ;
48585 PyObject * obj0 = 0 ;
48586 PyObject * obj1 = 0 ;
48587 char * kwnames[] = {
48588 (char *) "self",(char *) "button", NULL
48589 };
48590
48591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48593 if (!SWIG_IsOK(res1)) {
48594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48595 }
48596 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48598 if (!SWIG_IsOK(res2)) {
48599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48600 }
48601 arg2 = reinterpret_cast< wxButton * >(argp2);
48602 {
48603 PyThreadState* __tstate = wxPyBeginAllowThreads();
48604 (arg1)->AddButton(arg2);
48605 wxPyEndAllowThreads(__tstate);
48606 if (PyErr_Occurred()) SWIG_fail;
48607 }
48608 resultobj = SWIG_Py_Void();
48609 return resultobj;
48610 fail:
48611 return NULL;
48612 }
48613
48614
48615 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48616 PyObject *resultobj = 0;
48617 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48618 void *argp1 = 0 ;
48619 int res1 = 0 ;
48620 PyObject *swig_obj[1] ;
48621
48622 if (!args) SWIG_fail;
48623 swig_obj[0] = args;
48624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48625 if (!SWIG_IsOK(res1)) {
48626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48627 }
48628 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48629 {
48630 PyThreadState* __tstate = wxPyBeginAllowThreads();
48631 (arg1)->Realize();
48632 wxPyEndAllowThreads(__tstate);
48633 if (PyErr_Occurred()) SWIG_fail;
48634 }
48635 resultobj = SWIG_Py_Void();
48636 return resultobj;
48637 fail:
48638 return NULL;
48639 }
48640
48641
48642 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48643 PyObject *resultobj = 0;
48644 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48645 wxButton *arg2 = (wxButton *) 0 ;
48646 void *argp1 = 0 ;
48647 int res1 = 0 ;
48648 void *argp2 = 0 ;
48649 int res2 = 0 ;
48650 PyObject * obj0 = 0 ;
48651 PyObject * obj1 = 0 ;
48652 char * kwnames[] = {
48653 (char *) "self",(char *) "button", NULL
48654 };
48655
48656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48658 if (!SWIG_IsOK(res1)) {
48659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48660 }
48661 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48662 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48663 if (!SWIG_IsOK(res2)) {
48664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48665 }
48666 arg2 = reinterpret_cast< wxButton * >(argp2);
48667 {
48668 PyThreadState* __tstate = wxPyBeginAllowThreads();
48669 (arg1)->SetAffirmativeButton(arg2);
48670 wxPyEndAllowThreads(__tstate);
48671 if (PyErr_Occurred()) SWIG_fail;
48672 }
48673 resultobj = SWIG_Py_Void();
48674 return resultobj;
48675 fail:
48676 return NULL;
48677 }
48678
48679
48680 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48681 PyObject *resultobj = 0;
48682 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48683 wxButton *arg2 = (wxButton *) 0 ;
48684 void *argp1 = 0 ;
48685 int res1 = 0 ;
48686 void *argp2 = 0 ;
48687 int res2 = 0 ;
48688 PyObject * obj0 = 0 ;
48689 PyObject * obj1 = 0 ;
48690 char * kwnames[] = {
48691 (char *) "self",(char *) "button", NULL
48692 };
48693
48694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48696 if (!SWIG_IsOK(res1)) {
48697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48698 }
48699 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48700 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48701 if (!SWIG_IsOK(res2)) {
48702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48703 }
48704 arg2 = reinterpret_cast< wxButton * >(argp2);
48705 {
48706 PyThreadState* __tstate = wxPyBeginAllowThreads();
48707 (arg1)->SetNegativeButton(arg2);
48708 wxPyEndAllowThreads(__tstate);
48709 if (PyErr_Occurred()) SWIG_fail;
48710 }
48711 resultobj = SWIG_Py_Void();
48712 return resultobj;
48713 fail:
48714 return NULL;
48715 }
48716
48717
48718 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48719 PyObject *resultobj = 0;
48720 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48721 wxButton *arg2 = (wxButton *) 0 ;
48722 void *argp1 = 0 ;
48723 int res1 = 0 ;
48724 void *argp2 = 0 ;
48725 int res2 = 0 ;
48726 PyObject * obj0 = 0 ;
48727 PyObject * obj1 = 0 ;
48728 char * kwnames[] = {
48729 (char *) "self",(char *) "button", NULL
48730 };
48731
48732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48734 if (!SWIG_IsOK(res1)) {
48735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48736 }
48737 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48739 if (!SWIG_IsOK(res2)) {
48740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48741 }
48742 arg2 = reinterpret_cast< wxButton * >(argp2);
48743 {
48744 PyThreadState* __tstate = wxPyBeginAllowThreads();
48745 (arg1)->SetCancelButton(arg2);
48746 wxPyEndAllowThreads(__tstate);
48747 if (PyErr_Occurred()) SWIG_fail;
48748 }
48749 resultobj = SWIG_Py_Void();
48750 return resultobj;
48751 fail:
48752 return NULL;
48753 }
48754
48755
48756 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48757 PyObject *resultobj = 0;
48758 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48759 wxButton *result = 0 ;
48760 void *argp1 = 0 ;
48761 int res1 = 0 ;
48762 PyObject *swig_obj[1] ;
48763
48764 if (!args) SWIG_fail;
48765 swig_obj[0] = args;
48766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48767 if (!SWIG_IsOK(res1)) {
48768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48769 }
48770 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48771 {
48772 PyThreadState* __tstate = wxPyBeginAllowThreads();
48773 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48774 wxPyEndAllowThreads(__tstate);
48775 if (PyErr_Occurred()) SWIG_fail;
48776 }
48777 {
48778 resultobj = wxPyMake_wxObject(result, (bool)0);
48779 }
48780 return resultobj;
48781 fail:
48782 return NULL;
48783 }
48784
48785
48786 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48787 PyObject *resultobj = 0;
48788 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48789 wxButton *result = 0 ;
48790 void *argp1 = 0 ;
48791 int res1 = 0 ;
48792 PyObject *swig_obj[1] ;
48793
48794 if (!args) SWIG_fail;
48795 swig_obj[0] = args;
48796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48797 if (!SWIG_IsOK(res1)) {
48798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48799 }
48800 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48801 {
48802 PyThreadState* __tstate = wxPyBeginAllowThreads();
48803 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48804 wxPyEndAllowThreads(__tstate);
48805 if (PyErr_Occurred()) SWIG_fail;
48806 }
48807 {
48808 resultobj = wxPyMake_wxObject(result, (bool)0);
48809 }
48810 return resultobj;
48811 fail:
48812 return NULL;
48813 }
48814
48815
48816 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48817 PyObject *resultobj = 0;
48818 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48819 wxButton *result = 0 ;
48820 void *argp1 = 0 ;
48821 int res1 = 0 ;
48822 PyObject *swig_obj[1] ;
48823
48824 if (!args) SWIG_fail;
48825 swig_obj[0] = args;
48826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48827 if (!SWIG_IsOK(res1)) {
48828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48829 }
48830 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48831 {
48832 PyThreadState* __tstate = wxPyBeginAllowThreads();
48833 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48834 wxPyEndAllowThreads(__tstate);
48835 if (PyErr_Occurred()) SWIG_fail;
48836 }
48837 {
48838 resultobj = wxPyMake_wxObject(result, (bool)0);
48839 }
48840 return resultobj;
48841 fail:
48842 return NULL;
48843 }
48844
48845
48846 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48847 PyObject *resultobj = 0;
48848 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48849 wxButton *result = 0 ;
48850 void *argp1 = 0 ;
48851 int res1 = 0 ;
48852 PyObject *swig_obj[1] ;
48853
48854 if (!args) SWIG_fail;
48855 swig_obj[0] = args;
48856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48857 if (!SWIG_IsOK(res1)) {
48858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48859 }
48860 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48861 {
48862 PyThreadState* __tstate = wxPyBeginAllowThreads();
48863 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48864 wxPyEndAllowThreads(__tstate);
48865 if (PyErr_Occurred()) SWIG_fail;
48866 }
48867 {
48868 resultobj = wxPyMake_wxObject(result, (bool)0);
48869 }
48870 return resultobj;
48871 fail:
48872 return NULL;
48873 }
48874
48875
48876 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48877 PyObject *resultobj = 0;
48878 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48879 wxButton *result = 0 ;
48880 void *argp1 = 0 ;
48881 int res1 = 0 ;
48882 PyObject *swig_obj[1] ;
48883
48884 if (!args) SWIG_fail;
48885 swig_obj[0] = args;
48886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48887 if (!SWIG_IsOK(res1)) {
48888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48889 }
48890 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48891 {
48892 PyThreadState* __tstate = wxPyBeginAllowThreads();
48893 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48894 wxPyEndAllowThreads(__tstate);
48895 if (PyErr_Occurred()) SWIG_fail;
48896 }
48897 {
48898 resultobj = wxPyMake_wxObject(result, (bool)0);
48899 }
48900 return resultobj;
48901 fail:
48902 return NULL;
48903 }
48904
48905
48906 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48907 PyObject *obj;
48908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48909 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48910 return SWIG_Py_Void();
48911 }
48912
48913 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48914 return SWIG_Python_InitShadowInstance(args);
48915 }
48916
48917 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48918 PyObject *resultobj = 0;
48919 int arg1 = (int) 0 ;
48920 int arg2 = (int) 0 ;
48921 wxGBPosition *result = 0 ;
48922 int val1 ;
48923 int ecode1 = 0 ;
48924 int val2 ;
48925 int ecode2 = 0 ;
48926 PyObject * obj0 = 0 ;
48927 PyObject * obj1 = 0 ;
48928 char * kwnames[] = {
48929 (char *) "row",(char *) "col", NULL
48930 };
48931
48932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48933 if (obj0) {
48934 ecode1 = SWIG_AsVal_int(obj0, &val1);
48935 if (!SWIG_IsOK(ecode1)) {
48936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48937 }
48938 arg1 = static_cast< int >(val1);
48939 }
48940 if (obj1) {
48941 ecode2 = SWIG_AsVal_int(obj1, &val2);
48942 if (!SWIG_IsOK(ecode2)) {
48943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48944 }
48945 arg2 = static_cast< int >(val2);
48946 }
48947 {
48948 PyThreadState* __tstate = wxPyBeginAllowThreads();
48949 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48950 wxPyEndAllowThreads(__tstate);
48951 if (PyErr_Occurred()) SWIG_fail;
48952 }
48953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48954 return resultobj;
48955 fail:
48956 return NULL;
48957 }
48958
48959
48960 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48961 PyObject *resultobj = 0;
48962 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48963 void *argp1 = 0 ;
48964 int res1 = 0 ;
48965 PyObject *swig_obj[1] ;
48966
48967 if (!args) SWIG_fail;
48968 swig_obj[0] = args;
48969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48970 if (!SWIG_IsOK(res1)) {
48971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48972 }
48973 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48974 {
48975 PyThreadState* __tstate = wxPyBeginAllowThreads();
48976 delete arg1;
48977
48978 wxPyEndAllowThreads(__tstate);
48979 if (PyErr_Occurred()) SWIG_fail;
48980 }
48981 resultobj = SWIG_Py_Void();
48982 return resultobj;
48983 fail:
48984 return NULL;
48985 }
48986
48987
48988 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48989 PyObject *resultobj = 0;
48990 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48991 int result;
48992 void *argp1 = 0 ;
48993 int res1 = 0 ;
48994 PyObject *swig_obj[1] ;
48995
48996 if (!args) SWIG_fail;
48997 swig_obj[0] = args;
48998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48999 if (!SWIG_IsOK(res1)) {
49000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49001 }
49002 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49003 {
49004 PyThreadState* __tstate = wxPyBeginAllowThreads();
49005 result = (int)((wxGBPosition const *)arg1)->GetRow();
49006 wxPyEndAllowThreads(__tstate);
49007 if (PyErr_Occurred()) SWIG_fail;
49008 }
49009 resultobj = SWIG_From_int(static_cast< int >(result));
49010 return resultobj;
49011 fail:
49012 return NULL;
49013 }
49014
49015
49016 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49017 PyObject *resultobj = 0;
49018 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49019 int result;
49020 void *argp1 = 0 ;
49021 int res1 = 0 ;
49022 PyObject *swig_obj[1] ;
49023
49024 if (!args) SWIG_fail;
49025 swig_obj[0] = args;
49026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49027 if (!SWIG_IsOK(res1)) {
49028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49029 }
49030 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49031 {
49032 PyThreadState* __tstate = wxPyBeginAllowThreads();
49033 result = (int)((wxGBPosition const *)arg1)->GetCol();
49034 wxPyEndAllowThreads(__tstate);
49035 if (PyErr_Occurred()) SWIG_fail;
49036 }
49037 resultobj = SWIG_From_int(static_cast< int >(result));
49038 return resultobj;
49039 fail:
49040 return NULL;
49041 }
49042
49043
49044 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49045 PyObject *resultobj = 0;
49046 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49047 int arg2 ;
49048 void *argp1 = 0 ;
49049 int res1 = 0 ;
49050 int val2 ;
49051 int ecode2 = 0 ;
49052 PyObject * obj0 = 0 ;
49053 PyObject * obj1 = 0 ;
49054 char * kwnames[] = {
49055 (char *) "self",(char *) "row", NULL
49056 };
49057
49058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49060 if (!SWIG_IsOK(res1)) {
49061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49062 }
49063 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49064 ecode2 = SWIG_AsVal_int(obj1, &val2);
49065 if (!SWIG_IsOK(ecode2)) {
49066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49067 }
49068 arg2 = static_cast< int >(val2);
49069 {
49070 PyThreadState* __tstate = wxPyBeginAllowThreads();
49071 (arg1)->SetRow(arg2);
49072 wxPyEndAllowThreads(__tstate);
49073 if (PyErr_Occurred()) SWIG_fail;
49074 }
49075 resultobj = SWIG_Py_Void();
49076 return resultobj;
49077 fail:
49078 return NULL;
49079 }
49080
49081
49082 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49083 PyObject *resultobj = 0;
49084 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49085 int arg2 ;
49086 void *argp1 = 0 ;
49087 int res1 = 0 ;
49088 int val2 ;
49089 int ecode2 = 0 ;
49090 PyObject * obj0 = 0 ;
49091 PyObject * obj1 = 0 ;
49092 char * kwnames[] = {
49093 (char *) "self",(char *) "col", NULL
49094 };
49095
49096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49098 if (!SWIG_IsOK(res1)) {
49099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49100 }
49101 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49102 ecode2 = SWIG_AsVal_int(obj1, &val2);
49103 if (!SWIG_IsOK(ecode2)) {
49104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49105 }
49106 arg2 = static_cast< int >(val2);
49107 {
49108 PyThreadState* __tstate = wxPyBeginAllowThreads();
49109 (arg1)->SetCol(arg2);
49110 wxPyEndAllowThreads(__tstate);
49111 if (PyErr_Occurred()) SWIG_fail;
49112 }
49113 resultobj = SWIG_Py_Void();
49114 return resultobj;
49115 fail:
49116 return NULL;
49117 }
49118
49119
49120 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49121 PyObject *resultobj = 0;
49122 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49123 PyObject *arg2 = (PyObject *) 0 ;
49124 bool result;
49125 void *argp1 = 0 ;
49126 int res1 = 0 ;
49127 PyObject * obj0 = 0 ;
49128 PyObject * obj1 = 0 ;
49129 char * kwnames[] = {
49130 (char *) "self",(char *) "other", NULL
49131 };
49132
49133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49135 if (!SWIG_IsOK(res1)) {
49136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49137 }
49138 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49139 arg2 = obj1;
49140 {
49141 result = (bool)wxGBPosition___eq__(arg1,arg2);
49142 if (PyErr_Occurred()) SWIG_fail;
49143 }
49144 {
49145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49146 }
49147 return resultobj;
49148 fail:
49149 return NULL;
49150 }
49151
49152
49153 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49154 PyObject *resultobj = 0;
49155 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49156 PyObject *arg2 = (PyObject *) 0 ;
49157 bool result;
49158 void *argp1 = 0 ;
49159 int res1 = 0 ;
49160 PyObject * obj0 = 0 ;
49161 PyObject * obj1 = 0 ;
49162 char * kwnames[] = {
49163 (char *) "self",(char *) "other", NULL
49164 };
49165
49166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49168 if (!SWIG_IsOK(res1)) {
49169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49170 }
49171 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49172 arg2 = obj1;
49173 {
49174 result = (bool)wxGBPosition___ne__(arg1,arg2);
49175 if (PyErr_Occurred()) SWIG_fail;
49176 }
49177 {
49178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49179 }
49180 return resultobj;
49181 fail:
49182 return NULL;
49183 }
49184
49185
49186 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49187 PyObject *resultobj = 0;
49188 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49189 int arg2 = (int) 0 ;
49190 int arg3 = (int) 0 ;
49191 void *argp1 = 0 ;
49192 int res1 = 0 ;
49193 int val2 ;
49194 int ecode2 = 0 ;
49195 int val3 ;
49196 int ecode3 = 0 ;
49197 PyObject * obj0 = 0 ;
49198 PyObject * obj1 = 0 ;
49199 PyObject * obj2 = 0 ;
49200 char * kwnames[] = {
49201 (char *) "self",(char *) "row",(char *) "col", NULL
49202 };
49203
49204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49206 if (!SWIG_IsOK(res1)) {
49207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49208 }
49209 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49210 if (obj1) {
49211 ecode2 = SWIG_AsVal_int(obj1, &val2);
49212 if (!SWIG_IsOK(ecode2)) {
49213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49214 }
49215 arg2 = static_cast< int >(val2);
49216 }
49217 if (obj2) {
49218 ecode3 = SWIG_AsVal_int(obj2, &val3);
49219 if (!SWIG_IsOK(ecode3)) {
49220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49221 }
49222 arg3 = static_cast< int >(val3);
49223 }
49224 {
49225 PyThreadState* __tstate = wxPyBeginAllowThreads();
49226 wxGBPosition_Set(arg1,arg2,arg3);
49227 wxPyEndAllowThreads(__tstate);
49228 if (PyErr_Occurred()) SWIG_fail;
49229 }
49230 resultobj = SWIG_Py_Void();
49231 return resultobj;
49232 fail:
49233 return NULL;
49234 }
49235
49236
49237 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49238 PyObject *resultobj = 0;
49239 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49240 PyObject *result = 0 ;
49241 void *argp1 = 0 ;
49242 int res1 = 0 ;
49243 PyObject *swig_obj[1] ;
49244
49245 if (!args) SWIG_fail;
49246 swig_obj[0] = args;
49247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49248 if (!SWIG_IsOK(res1)) {
49249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49250 }
49251 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49252 {
49253 PyThreadState* __tstate = wxPyBeginAllowThreads();
49254 result = (PyObject *)wxGBPosition_Get(arg1);
49255 wxPyEndAllowThreads(__tstate);
49256 if (PyErr_Occurred()) SWIG_fail;
49257 }
49258 resultobj = result;
49259 return resultobj;
49260 fail:
49261 return NULL;
49262 }
49263
49264
49265 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49266 PyObject *obj;
49267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49268 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49269 return SWIG_Py_Void();
49270 }
49271
49272 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49273 return SWIG_Python_InitShadowInstance(args);
49274 }
49275
49276 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49277 PyObject *resultobj = 0;
49278 int arg1 = (int) 1 ;
49279 int arg2 = (int) 1 ;
49280 wxGBSpan *result = 0 ;
49281 int val1 ;
49282 int ecode1 = 0 ;
49283 int val2 ;
49284 int ecode2 = 0 ;
49285 PyObject * obj0 = 0 ;
49286 PyObject * obj1 = 0 ;
49287 char * kwnames[] = {
49288 (char *) "rowspan",(char *) "colspan", NULL
49289 };
49290
49291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49292 if (obj0) {
49293 ecode1 = SWIG_AsVal_int(obj0, &val1);
49294 if (!SWIG_IsOK(ecode1)) {
49295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49296 }
49297 arg1 = static_cast< int >(val1);
49298 }
49299 if (obj1) {
49300 ecode2 = SWIG_AsVal_int(obj1, &val2);
49301 if (!SWIG_IsOK(ecode2)) {
49302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49303 }
49304 arg2 = static_cast< int >(val2);
49305 }
49306 {
49307 PyThreadState* __tstate = wxPyBeginAllowThreads();
49308 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49309 wxPyEndAllowThreads(__tstate);
49310 if (PyErr_Occurred()) SWIG_fail;
49311 }
49312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49313 return resultobj;
49314 fail:
49315 return NULL;
49316 }
49317
49318
49319 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49320 PyObject *resultobj = 0;
49321 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49322 void *argp1 = 0 ;
49323 int res1 = 0 ;
49324 PyObject *swig_obj[1] ;
49325
49326 if (!args) SWIG_fail;
49327 swig_obj[0] = args;
49328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49329 if (!SWIG_IsOK(res1)) {
49330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49331 }
49332 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49333 {
49334 PyThreadState* __tstate = wxPyBeginAllowThreads();
49335 delete arg1;
49336
49337 wxPyEndAllowThreads(__tstate);
49338 if (PyErr_Occurred()) SWIG_fail;
49339 }
49340 resultobj = SWIG_Py_Void();
49341 return resultobj;
49342 fail:
49343 return NULL;
49344 }
49345
49346
49347 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49348 PyObject *resultobj = 0;
49349 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49350 int result;
49351 void *argp1 = 0 ;
49352 int res1 = 0 ;
49353 PyObject *swig_obj[1] ;
49354
49355 if (!args) SWIG_fail;
49356 swig_obj[0] = args;
49357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49358 if (!SWIG_IsOK(res1)) {
49359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49360 }
49361 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49362 {
49363 PyThreadState* __tstate = wxPyBeginAllowThreads();
49364 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49365 wxPyEndAllowThreads(__tstate);
49366 if (PyErr_Occurred()) SWIG_fail;
49367 }
49368 resultobj = SWIG_From_int(static_cast< int >(result));
49369 return resultobj;
49370 fail:
49371 return NULL;
49372 }
49373
49374
49375 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49376 PyObject *resultobj = 0;
49377 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49378 int result;
49379 void *argp1 = 0 ;
49380 int res1 = 0 ;
49381 PyObject *swig_obj[1] ;
49382
49383 if (!args) SWIG_fail;
49384 swig_obj[0] = args;
49385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49386 if (!SWIG_IsOK(res1)) {
49387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49388 }
49389 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49390 {
49391 PyThreadState* __tstate = wxPyBeginAllowThreads();
49392 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49393 wxPyEndAllowThreads(__tstate);
49394 if (PyErr_Occurred()) SWIG_fail;
49395 }
49396 resultobj = SWIG_From_int(static_cast< int >(result));
49397 return resultobj;
49398 fail:
49399 return NULL;
49400 }
49401
49402
49403 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49404 PyObject *resultobj = 0;
49405 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49406 int arg2 ;
49407 void *argp1 = 0 ;
49408 int res1 = 0 ;
49409 int val2 ;
49410 int ecode2 = 0 ;
49411 PyObject * obj0 = 0 ;
49412 PyObject * obj1 = 0 ;
49413 char * kwnames[] = {
49414 (char *) "self",(char *) "rowspan", NULL
49415 };
49416
49417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49419 if (!SWIG_IsOK(res1)) {
49420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49421 }
49422 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49423 ecode2 = SWIG_AsVal_int(obj1, &val2);
49424 if (!SWIG_IsOK(ecode2)) {
49425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49426 }
49427 arg2 = static_cast< int >(val2);
49428 {
49429 PyThreadState* __tstate = wxPyBeginAllowThreads();
49430 (arg1)->SetRowspan(arg2);
49431 wxPyEndAllowThreads(__tstate);
49432 if (PyErr_Occurred()) SWIG_fail;
49433 }
49434 resultobj = SWIG_Py_Void();
49435 return resultobj;
49436 fail:
49437 return NULL;
49438 }
49439
49440
49441 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49442 PyObject *resultobj = 0;
49443 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49444 int arg2 ;
49445 void *argp1 = 0 ;
49446 int res1 = 0 ;
49447 int val2 ;
49448 int ecode2 = 0 ;
49449 PyObject * obj0 = 0 ;
49450 PyObject * obj1 = 0 ;
49451 char * kwnames[] = {
49452 (char *) "self",(char *) "colspan", NULL
49453 };
49454
49455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49457 if (!SWIG_IsOK(res1)) {
49458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49459 }
49460 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49461 ecode2 = SWIG_AsVal_int(obj1, &val2);
49462 if (!SWIG_IsOK(ecode2)) {
49463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49464 }
49465 arg2 = static_cast< int >(val2);
49466 {
49467 PyThreadState* __tstate = wxPyBeginAllowThreads();
49468 (arg1)->SetColspan(arg2);
49469 wxPyEndAllowThreads(__tstate);
49470 if (PyErr_Occurred()) SWIG_fail;
49471 }
49472 resultobj = SWIG_Py_Void();
49473 return resultobj;
49474 fail:
49475 return NULL;
49476 }
49477
49478
49479 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49480 PyObject *resultobj = 0;
49481 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49482 PyObject *arg2 = (PyObject *) 0 ;
49483 bool result;
49484 void *argp1 = 0 ;
49485 int res1 = 0 ;
49486 PyObject * obj0 = 0 ;
49487 PyObject * obj1 = 0 ;
49488 char * kwnames[] = {
49489 (char *) "self",(char *) "other", NULL
49490 };
49491
49492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49494 if (!SWIG_IsOK(res1)) {
49495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49496 }
49497 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49498 arg2 = obj1;
49499 {
49500 result = (bool)wxGBSpan___eq__(arg1,arg2);
49501 if (PyErr_Occurred()) SWIG_fail;
49502 }
49503 {
49504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49505 }
49506 return resultobj;
49507 fail:
49508 return NULL;
49509 }
49510
49511
49512 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49513 PyObject *resultobj = 0;
49514 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49515 PyObject *arg2 = (PyObject *) 0 ;
49516 bool result;
49517 void *argp1 = 0 ;
49518 int res1 = 0 ;
49519 PyObject * obj0 = 0 ;
49520 PyObject * obj1 = 0 ;
49521 char * kwnames[] = {
49522 (char *) "self",(char *) "other", NULL
49523 };
49524
49525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49527 if (!SWIG_IsOK(res1)) {
49528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49529 }
49530 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49531 arg2 = obj1;
49532 {
49533 result = (bool)wxGBSpan___ne__(arg1,arg2);
49534 if (PyErr_Occurred()) SWIG_fail;
49535 }
49536 {
49537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49538 }
49539 return resultobj;
49540 fail:
49541 return NULL;
49542 }
49543
49544
49545 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49546 PyObject *resultobj = 0;
49547 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49548 int arg2 = (int) 1 ;
49549 int arg3 = (int) 1 ;
49550 void *argp1 = 0 ;
49551 int res1 = 0 ;
49552 int val2 ;
49553 int ecode2 = 0 ;
49554 int val3 ;
49555 int ecode3 = 0 ;
49556 PyObject * obj0 = 0 ;
49557 PyObject * obj1 = 0 ;
49558 PyObject * obj2 = 0 ;
49559 char * kwnames[] = {
49560 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49561 };
49562
49563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49565 if (!SWIG_IsOK(res1)) {
49566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49567 }
49568 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49569 if (obj1) {
49570 ecode2 = SWIG_AsVal_int(obj1, &val2);
49571 if (!SWIG_IsOK(ecode2)) {
49572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49573 }
49574 arg2 = static_cast< int >(val2);
49575 }
49576 if (obj2) {
49577 ecode3 = SWIG_AsVal_int(obj2, &val3);
49578 if (!SWIG_IsOK(ecode3)) {
49579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49580 }
49581 arg3 = static_cast< int >(val3);
49582 }
49583 {
49584 PyThreadState* __tstate = wxPyBeginAllowThreads();
49585 wxGBSpan_Set(arg1,arg2,arg3);
49586 wxPyEndAllowThreads(__tstate);
49587 if (PyErr_Occurred()) SWIG_fail;
49588 }
49589 resultobj = SWIG_Py_Void();
49590 return resultobj;
49591 fail:
49592 return NULL;
49593 }
49594
49595
49596 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49597 PyObject *resultobj = 0;
49598 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49599 PyObject *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_wxGBSpan, 0 | 0 );
49607 if (!SWIG_IsOK(res1)) {
49608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49609 }
49610 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49611 {
49612 PyThreadState* __tstate = wxPyBeginAllowThreads();
49613 result = (PyObject *)wxGBSpan_Get(arg1);
49614 wxPyEndAllowThreads(__tstate);
49615 if (PyErr_Occurred()) SWIG_fail;
49616 }
49617 resultobj = result;
49618 return resultobj;
49619 fail:
49620 return NULL;
49621 }
49622
49623
49624 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49625 PyObject *obj;
49626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49627 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49628 return SWIG_Py_Void();
49629 }
49630
49631 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49632 return SWIG_Python_InitShadowInstance(args);
49633 }
49634
49635 SWIGINTERN int DefaultSpan_set(PyObject *) {
49636 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49637 return 1;
49638 }
49639
49640
49641 SWIGINTERN PyObject *DefaultSpan_get(void) {
49642 PyObject *pyobj = 0;
49643
49644 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49645 return pyobj;
49646 }
49647
49648
49649 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49650 PyObject *resultobj = 0;
49651 wxGBSizerItem *result = 0 ;
49652
49653 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49654 {
49655 PyThreadState* __tstate = wxPyBeginAllowThreads();
49656 result = (wxGBSizerItem *)new wxGBSizerItem();
49657 wxPyEndAllowThreads(__tstate);
49658 if (PyErr_Occurred()) SWIG_fail;
49659 }
49660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49661 return resultobj;
49662 fail:
49663 return NULL;
49664 }
49665
49666
49667 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49668 PyObject *resultobj = 0;
49669 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49670 void *argp1 = 0 ;
49671 int res1 = 0 ;
49672 PyObject *swig_obj[1] ;
49673
49674 if (!args) SWIG_fail;
49675 swig_obj[0] = args;
49676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49677 if (!SWIG_IsOK(res1)) {
49678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49679 }
49680 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49681 {
49682 PyThreadState* __tstate = wxPyBeginAllowThreads();
49683 delete arg1;
49684
49685 wxPyEndAllowThreads(__tstate);
49686 if (PyErr_Occurred()) SWIG_fail;
49687 }
49688 resultobj = SWIG_Py_Void();
49689 return resultobj;
49690 fail:
49691 return NULL;
49692 }
49693
49694
49695 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49696 PyObject *resultobj = 0;
49697 wxWindow *arg1 = (wxWindow *) 0 ;
49698 wxGBPosition *arg2 = 0 ;
49699 wxGBSpan *arg3 = 0 ;
49700 int arg4 ;
49701 int arg5 ;
49702 PyObject *arg6 = (PyObject *) NULL ;
49703 wxGBSizerItem *result = 0 ;
49704 void *argp1 = 0 ;
49705 int res1 = 0 ;
49706 wxGBPosition temp2 ;
49707 wxGBSpan temp3 ;
49708 int val4 ;
49709 int ecode4 = 0 ;
49710 int val5 ;
49711 int ecode5 = 0 ;
49712 PyObject * obj0 = 0 ;
49713 PyObject * obj1 = 0 ;
49714 PyObject * obj2 = 0 ;
49715 PyObject * obj3 = 0 ;
49716 PyObject * obj4 = 0 ;
49717 PyObject * obj5 = 0 ;
49718 char * kwnames[] = {
49719 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49720 };
49721
49722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49724 if (!SWIG_IsOK(res1)) {
49725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49726 }
49727 arg1 = reinterpret_cast< wxWindow * >(argp1);
49728 {
49729 arg2 = &temp2;
49730 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49731 }
49732 {
49733 arg3 = &temp3;
49734 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49735 }
49736 ecode4 = SWIG_AsVal_int(obj3, &val4);
49737 if (!SWIG_IsOK(ecode4)) {
49738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49739 }
49740 arg4 = static_cast< int >(val4);
49741 ecode5 = SWIG_AsVal_int(obj4, &val5);
49742 if (!SWIG_IsOK(ecode5)) {
49743 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49744 }
49745 arg5 = static_cast< int >(val5);
49746 if (obj5) {
49747 arg6 = obj5;
49748 }
49749 {
49750 PyThreadState* __tstate = wxPyBeginAllowThreads();
49751 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49752 wxPyEndAllowThreads(__tstate);
49753 if (PyErr_Occurred()) SWIG_fail;
49754 }
49755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49756 return resultobj;
49757 fail:
49758 return NULL;
49759 }
49760
49761
49762 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49763 PyObject *resultobj = 0;
49764 wxSizer *arg1 = (wxSizer *) 0 ;
49765 wxGBPosition *arg2 = 0 ;
49766 wxGBSpan *arg3 = 0 ;
49767 int arg4 ;
49768 int arg5 ;
49769 PyObject *arg6 = (PyObject *) NULL ;
49770 wxGBSizerItem *result = 0 ;
49771 int res1 = 0 ;
49772 wxGBPosition temp2 ;
49773 wxGBSpan temp3 ;
49774 int val4 ;
49775 int ecode4 = 0 ;
49776 int val5 ;
49777 int ecode5 = 0 ;
49778 PyObject * obj0 = 0 ;
49779 PyObject * obj1 = 0 ;
49780 PyObject * obj2 = 0 ;
49781 PyObject * obj3 = 0 ;
49782 PyObject * obj4 = 0 ;
49783 PyObject * obj5 = 0 ;
49784 char * kwnames[] = {
49785 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49786 };
49787
49788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49789 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49790 if (!SWIG_IsOK(res1)) {
49791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49792 }
49793 {
49794 arg2 = &temp2;
49795 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49796 }
49797 {
49798 arg3 = &temp3;
49799 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49800 }
49801 ecode4 = SWIG_AsVal_int(obj3, &val4);
49802 if (!SWIG_IsOK(ecode4)) {
49803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49804 }
49805 arg4 = static_cast< int >(val4);
49806 ecode5 = SWIG_AsVal_int(obj4, &val5);
49807 if (!SWIG_IsOK(ecode5)) {
49808 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49809 }
49810 arg5 = static_cast< int >(val5);
49811 if (obj5) {
49812 arg6 = obj5;
49813 }
49814 {
49815 PyThreadState* __tstate = wxPyBeginAllowThreads();
49816 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49817 wxPyEndAllowThreads(__tstate);
49818 if (PyErr_Occurred()) SWIG_fail;
49819 }
49820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49821 return resultobj;
49822 fail:
49823 return NULL;
49824 }
49825
49826
49827 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49828 PyObject *resultobj = 0;
49829 int arg1 ;
49830 int arg2 ;
49831 wxGBPosition *arg3 = 0 ;
49832 wxGBSpan *arg4 = 0 ;
49833 int arg5 ;
49834 int arg6 ;
49835 PyObject *arg7 = (PyObject *) NULL ;
49836 wxGBSizerItem *result = 0 ;
49837 int val1 ;
49838 int ecode1 = 0 ;
49839 int val2 ;
49840 int ecode2 = 0 ;
49841 wxGBPosition temp3 ;
49842 wxGBSpan temp4 ;
49843 int val5 ;
49844 int ecode5 = 0 ;
49845 int val6 ;
49846 int ecode6 = 0 ;
49847 PyObject * obj0 = 0 ;
49848 PyObject * obj1 = 0 ;
49849 PyObject * obj2 = 0 ;
49850 PyObject * obj3 = 0 ;
49851 PyObject * obj4 = 0 ;
49852 PyObject * obj5 = 0 ;
49853 PyObject * obj6 = 0 ;
49854 char * kwnames[] = {
49855 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49856 };
49857
49858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49859 ecode1 = SWIG_AsVal_int(obj0, &val1);
49860 if (!SWIG_IsOK(ecode1)) {
49861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49862 }
49863 arg1 = static_cast< int >(val1);
49864 ecode2 = SWIG_AsVal_int(obj1, &val2);
49865 if (!SWIG_IsOK(ecode2)) {
49866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49867 }
49868 arg2 = static_cast< int >(val2);
49869 {
49870 arg3 = &temp3;
49871 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49872 }
49873 {
49874 arg4 = &temp4;
49875 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49876 }
49877 ecode5 = SWIG_AsVal_int(obj4, &val5);
49878 if (!SWIG_IsOK(ecode5)) {
49879 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49880 }
49881 arg5 = static_cast< int >(val5);
49882 ecode6 = SWIG_AsVal_int(obj5, &val6);
49883 if (!SWIG_IsOK(ecode6)) {
49884 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49885 }
49886 arg6 = static_cast< int >(val6);
49887 if (obj6) {
49888 arg7 = obj6;
49889 }
49890 {
49891 PyThreadState* __tstate = wxPyBeginAllowThreads();
49892 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49893 wxPyEndAllowThreads(__tstate);
49894 if (PyErr_Occurred()) SWIG_fail;
49895 }
49896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49897 return resultobj;
49898 fail:
49899 return NULL;
49900 }
49901
49902
49903 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49904 PyObject *resultobj = 0;
49905 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49906 wxGBPosition result;
49907 void *argp1 = 0 ;
49908 int res1 = 0 ;
49909 PyObject *swig_obj[1] ;
49910
49911 if (!args) SWIG_fail;
49912 swig_obj[0] = args;
49913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49914 if (!SWIG_IsOK(res1)) {
49915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49916 }
49917 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49918 {
49919 PyThreadState* __tstate = wxPyBeginAllowThreads();
49920 result = ((wxGBSizerItem const *)arg1)->GetPos();
49921 wxPyEndAllowThreads(__tstate);
49922 if (PyErr_Occurred()) SWIG_fail;
49923 }
49924 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49925 return resultobj;
49926 fail:
49927 return NULL;
49928 }
49929
49930
49931 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49932 PyObject *resultobj = 0;
49933 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49934 wxGBSpan result;
49935 void *argp1 = 0 ;
49936 int res1 = 0 ;
49937 PyObject *swig_obj[1] ;
49938
49939 if (!args) SWIG_fail;
49940 swig_obj[0] = args;
49941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49942 if (!SWIG_IsOK(res1)) {
49943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49944 }
49945 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49946 {
49947 PyThreadState* __tstate = wxPyBeginAllowThreads();
49948 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49949 wxPyEndAllowThreads(__tstate);
49950 if (PyErr_Occurred()) SWIG_fail;
49951 }
49952 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49953 return resultobj;
49954 fail:
49955 return NULL;
49956 }
49957
49958
49959 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49960 PyObject *resultobj = 0;
49961 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49962 wxGBPosition *arg2 = 0 ;
49963 bool result;
49964 void *argp1 = 0 ;
49965 int res1 = 0 ;
49966 wxGBPosition temp2 ;
49967 PyObject * obj0 = 0 ;
49968 PyObject * obj1 = 0 ;
49969 char * kwnames[] = {
49970 (char *) "self",(char *) "pos", NULL
49971 };
49972
49973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49975 if (!SWIG_IsOK(res1)) {
49976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49977 }
49978 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49979 {
49980 arg2 = &temp2;
49981 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49982 }
49983 {
49984 PyThreadState* __tstate = wxPyBeginAllowThreads();
49985 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49986 wxPyEndAllowThreads(__tstate);
49987 if (PyErr_Occurred()) SWIG_fail;
49988 }
49989 {
49990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49991 }
49992 return resultobj;
49993 fail:
49994 return NULL;
49995 }
49996
49997
49998 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49999 PyObject *resultobj = 0;
50000 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50001 wxGBSpan *arg2 = 0 ;
50002 bool result;
50003 void *argp1 = 0 ;
50004 int res1 = 0 ;
50005 wxGBSpan temp2 ;
50006 PyObject * obj0 = 0 ;
50007 PyObject * obj1 = 0 ;
50008 char * kwnames[] = {
50009 (char *) "self",(char *) "span", NULL
50010 };
50011
50012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50014 if (!SWIG_IsOK(res1)) {
50015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50016 }
50017 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50018 {
50019 arg2 = &temp2;
50020 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50021 }
50022 {
50023 PyThreadState* __tstate = wxPyBeginAllowThreads();
50024 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50025 wxPyEndAllowThreads(__tstate);
50026 if (PyErr_Occurred()) SWIG_fail;
50027 }
50028 {
50029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50030 }
50031 return resultobj;
50032 fail:
50033 return NULL;
50034 }
50035
50036
50037 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50038 PyObject *resultobj = 0;
50039 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50040 wxGBSizerItem *arg2 = 0 ;
50041 bool result;
50042 void *argp1 = 0 ;
50043 int res1 = 0 ;
50044 void *argp2 = 0 ;
50045 int res2 = 0 ;
50046 PyObject * obj0 = 0 ;
50047 PyObject * obj1 = 0 ;
50048 char * kwnames[] = {
50049 (char *) "self",(char *) "other", NULL
50050 };
50051
50052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50054 if (!SWIG_IsOK(res1)) {
50055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50056 }
50057 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50058 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50059 if (!SWIG_IsOK(res2)) {
50060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50061 }
50062 if (!argp2) {
50063 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50064 }
50065 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50066 {
50067 PyThreadState* __tstate = wxPyBeginAllowThreads();
50068 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50069 wxPyEndAllowThreads(__tstate);
50070 if (PyErr_Occurred()) SWIG_fail;
50071 }
50072 {
50073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50074 }
50075 return resultobj;
50076 fail:
50077 return NULL;
50078 }
50079
50080
50081 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50082 PyObject *resultobj = 0;
50083 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50084 wxGBPosition *arg2 = 0 ;
50085 wxGBSpan *arg3 = 0 ;
50086 bool result;
50087 void *argp1 = 0 ;
50088 int res1 = 0 ;
50089 wxGBPosition temp2 ;
50090 wxGBSpan temp3 ;
50091 PyObject * obj0 = 0 ;
50092 PyObject * obj1 = 0 ;
50093 PyObject * obj2 = 0 ;
50094 char * kwnames[] = {
50095 (char *) "self",(char *) "pos",(char *) "span", NULL
50096 };
50097
50098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50100 if (!SWIG_IsOK(res1)) {
50101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50102 }
50103 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50104 {
50105 arg2 = &temp2;
50106 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50107 }
50108 {
50109 arg3 = &temp3;
50110 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50111 }
50112 {
50113 PyThreadState* __tstate = wxPyBeginAllowThreads();
50114 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50115 wxPyEndAllowThreads(__tstate);
50116 if (PyErr_Occurred()) SWIG_fail;
50117 }
50118 {
50119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50120 }
50121 return resultobj;
50122 fail:
50123 return NULL;
50124 }
50125
50126
50127 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50128 PyObject *resultobj = 0;
50129 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50130 wxGBPosition result;
50131 void *argp1 = 0 ;
50132 int res1 = 0 ;
50133 PyObject *swig_obj[1] ;
50134
50135 if (!args) SWIG_fail;
50136 swig_obj[0] = args;
50137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50138 if (!SWIG_IsOK(res1)) {
50139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50140 }
50141 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50142 {
50143 PyThreadState* __tstate = wxPyBeginAllowThreads();
50144 result = wxGBSizerItem_GetEndPos(arg1);
50145 wxPyEndAllowThreads(__tstate);
50146 if (PyErr_Occurred()) SWIG_fail;
50147 }
50148 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50149 return resultobj;
50150 fail:
50151 return NULL;
50152 }
50153
50154
50155 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50156 PyObject *resultobj = 0;
50157 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50158 wxGridBagSizer *result = 0 ;
50159 void *argp1 = 0 ;
50160 int res1 = 0 ;
50161 PyObject *swig_obj[1] ;
50162
50163 if (!args) SWIG_fail;
50164 swig_obj[0] = args;
50165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50166 if (!SWIG_IsOK(res1)) {
50167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50168 }
50169 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50170 {
50171 PyThreadState* __tstate = wxPyBeginAllowThreads();
50172 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50173 wxPyEndAllowThreads(__tstate);
50174 if (PyErr_Occurred()) SWIG_fail;
50175 }
50176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50177 return resultobj;
50178 fail:
50179 return NULL;
50180 }
50181
50182
50183 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50184 PyObject *resultobj = 0;
50185 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50186 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50187 void *argp1 = 0 ;
50188 int res1 = 0 ;
50189 void *argp2 = 0 ;
50190 int res2 = 0 ;
50191 PyObject * obj0 = 0 ;
50192 PyObject * obj1 = 0 ;
50193 char * kwnames[] = {
50194 (char *) "self",(char *) "sizer", NULL
50195 };
50196
50197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50199 if (!SWIG_IsOK(res1)) {
50200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50201 }
50202 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50204 if (!SWIG_IsOK(res2)) {
50205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50206 }
50207 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50208 {
50209 PyThreadState* __tstate = wxPyBeginAllowThreads();
50210 (arg1)->SetGBSizer(arg2);
50211 wxPyEndAllowThreads(__tstate);
50212 if (PyErr_Occurred()) SWIG_fail;
50213 }
50214 resultobj = SWIG_Py_Void();
50215 return resultobj;
50216 fail:
50217 return NULL;
50218 }
50219
50220
50221 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50222 PyObject *obj;
50223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50224 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50225 return SWIG_Py_Void();
50226 }
50227
50228 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50229 return SWIG_Python_InitShadowInstance(args);
50230 }
50231
50232 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50233 PyObject *resultobj = 0;
50234 int arg1 = (int) 0 ;
50235 int arg2 = (int) 0 ;
50236 wxGridBagSizer *result = 0 ;
50237 int val1 ;
50238 int ecode1 = 0 ;
50239 int val2 ;
50240 int ecode2 = 0 ;
50241 PyObject * obj0 = 0 ;
50242 PyObject * obj1 = 0 ;
50243 char * kwnames[] = {
50244 (char *) "vgap",(char *) "hgap", NULL
50245 };
50246
50247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50248 if (obj0) {
50249 ecode1 = SWIG_AsVal_int(obj0, &val1);
50250 if (!SWIG_IsOK(ecode1)) {
50251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50252 }
50253 arg1 = static_cast< int >(val1);
50254 }
50255 if (obj1) {
50256 ecode2 = SWIG_AsVal_int(obj1, &val2);
50257 if (!SWIG_IsOK(ecode2)) {
50258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50259 }
50260 arg2 = static_cast< int >(val2);
50261 }
50262 {
50263 PyThreadState* __tstate = wxPyBeginAllowThreads();
50264 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50265 wxPyEndAllowThreads(__tstate);
50266 if (PyErr_Occurred()) SWIG_fail;
50267 }
50268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50269 return resultobj;
50270 fail:
50271 return NULL;
50272 }
50273
50274
50275 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50276 PyObject *resultobj = 0;
50277 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50278 PyObject *arg2 = (PyObject *) 0 ;
50279 wxGBPosition *arg3 = 0 ;
50280 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50281 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50282 int arg5 = (int) 0 ;
50283 int arg6 = (int) 0 ;
50284 PyObject *arg7 = (PyObject *) NULL ;
50285 wxGBSizerItem *result = 0 ;
50286 void *argp1 = 0 ;
50287 int res1 = 0 ;
50288 wxGBPosition temp3 ;
50289 wxGBSpan temp4 ;
50290 int val5 ;
50291 int ecode5 = 0 ;
50292 int val6 ;
50293 int ecode6 = 0 ;
50294 PyObject * obj0 = 0 ;
50295 PyObject * obj1 = 0 ;
50296 PyObject * obj2 = 0 ;
50297 PyObject * obj3 = 0 ;
50298 PyObject * obj4 = 0 ;
50299 PyObject * obj5 = 0 ;
50300 PyObject * obj6 = 0 ;
50301 char * kwnames[] = {
50302 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50303 };
50304
50305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50307 if (!SWIG_IsOK(res1)) {
50308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50309 }
50310 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50311 arg2 = obj1;
50312 {
50313 arg3 = &temp3;
50314 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50315 }
50316 if (obj3) {
50317 {
50318 arg4 = &temp4;
50319 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50320 }
50321 }
50322 if (obj4) {
50323 ecode5 = SWIG_AsVal_int(obj4, &val5);
50324 if (!SWIG_IsOK(ecode5)) {
50325 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50326 }
50327 arg5 = static_cast< int >(val5);
50328 }
50329 if (obj5) {
50330 ecode6 = SWIG_AsVal_int(obj5, &val6);
50331 if (!SWIG_IsOK(ecode6)) {
50332 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50333 }
50334 arg6 = static_cast< int >(val6);
50335 }
50336 if (obj6) {
50337 arg7 = obj6;
50338 }
50339 {
50340 PyThreadState* __tstate = wxPyBeginAllowThreads();
50341 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50342 wxPyEndAllowThreads(__tstate);
50343 if (PyErr_Occurred()) SWIG_fail;
50344 }
50345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50346 return resultobj;
50347 fail:
50348 return NULL;
50349 }
50350
50351
50352 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50353 PyObject *resultobj = 0;
50354 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50355 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50356 wxGBSizerItem *result = 0 ;
50357 void *argp1 = 0 ;
50358 int res1 = 0 ;
50359 int res2 = 0 ;
50360 PyObject * obj0 = 0 ;
50361 PyObject * obj1 = 0 ;
50362 char * kwnames[] = {
50363 (char *) "self",(char *) "item", NULL
50364 };
50365
50366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50368 if (!SWIG_IsOK(res1)) {
50369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50370 }
50371 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50372 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50373 if (!SWIG_IsOK(res2)) {
50374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50375 }
50376 {
50377 PyThreadState* __tstate = wxPyBeginAllowThreads();
50378 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50379 wxPyEndAllowThreads(__tstate);
50380 if (PyErr_Occurred()) SWIG_fail;
50381 }
50382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50383 return resultobj;
50384 fail:
50385 return NULL;
50386 }
50387
50388
50389 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50390 PyObject *resultobj = 0;
50391 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50392 int arg2 ;
50393 int arg3 ;
50394 wxSize result;
50395 void *argp1 = 0 ;
50396 int res1 = 0 ;
50397 int val2 ;
50398 int ecode2 = 0 ;
50399 int val3 ;
50400 int ecode3 = 0 ;
50401 PyObject * obj0 = 0 ;
50402 PyObject * obj1 = 0 ;
50403 PyObject * obj2 = 0 ;
50404 char * kwnames[] = {
50405 (char *) "self",(char *) "row",(char *) "col", NULL
50406 };
50407
50408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50410 if (!SWIG_IsOK(res1)) {
50411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50412 }
50413 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50414 ecode2 = SWIG_AsVal_int(obj1, &val2);
50415 if (!SWIG_IsOK(ecode2)) {
50416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50417 }
50418 arg2 = static_cast< int >(val2);
50419 ecode3 = SWIG_AsVal_int(obj2, &val3);
50420 if (!SWIG_IsOK(ecode3)) {
50421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50422 }
50423 arg3 = static_cast< int >(val3);
50424 {
50425 PyThreadState* __tstate = wxPyBeginAllowThreads();
50426 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50427 wxPyEndAllowThreads(__tstate);
50428 if (PyErr_Occurred()) SWIG_fail;
50429 }
50430 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50431 return resultobj;
50432 fail:
50433 return NULL;
50434 }
50435
50436
50437 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50438 PyObject *resultobj = 0;
50439 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50440 wxSize result;
50441 void *argp1 = 0 ;
50442 int res1 = 0 ;
50443 PyObject *swig_obj[1] ;
50444
50445 if (!args) SWIG_fail;
50446 swig_obj[0] = args;
50447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50448 if (!SWIG_IsOK(res1)) {
50449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50450 }
50451 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50452 {
50453 PyThreadState* __tstate = wxPyBeginAllowThreads();
50454 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50455 wxPyEndAllowThreads(__tstate);
50456 if (PyErr_Occurred()) SWIG_fail;
50457 }
50458 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50459 return resultobj;
50460 fail:
50461 return NULL;
50462 }
50463
50464
50465 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50466 PyObject *resultobj = 0;
50467 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50468 wxSize *arg2 = 0 ;
50469 void *argp1 = 0 ;
50470 int res1 = 0 ;
50471 wxSize temp2 ;
50472 PyObject * obj0 = 0 ;
50473 PyObject * obj1 = 0 ;
50474 char * kwnames[] = {
50475 (char *) "self",(char *) "sz", NULL
50476 };
50477
50478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50480 if (!SWIG_IsOK(res1)) {
50481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50482 }
50483 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50484 {
50485 arg2 = &temp2;
50486 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50487 }
50488 {
50489 PyThreadState* __tstate = wxPyBeginAllowThreads();
50490 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50491 wxPyEndAllowThreads(__tstate);
50492 if (PyErr_Occurred()) SWIG_fail;
50493 }
50494 resultobj = SWIG_Py_Void();
50495 return resultobj;
50496 fail:
50497 return NULL;
50498 }
50499
50500
50501 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50502 PyObject *resultobj = 0;
50503 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50504 wxWindow *arg2 = (wxWindow *) 0 ;
50505 wxGBPosition result;
50506 void *argp1 = 0 ;
50507 int res1 = 0 ;
50508 void *argp2 = 0 ;
50509 int res2 = 0 ;
50510
50511 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50513 if (!SWIG_IsOK(res1)) {
50514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50515 }
50516 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50517 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50518 if (!SWIG_IsOK(res2)) {
50519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50520 }
50521 arg2 = reinterpret_cast< wxWindow * >(argp2);
50522 {
50523 PyThreadState* __tstate = wxPyBeginAllowThreads();
50524 result = (arg1)->GetItemPosition(arg2);
50525 wxPyEndAllowThreads(__tstate);
50526 if (PyErr_Occurred()) SWIG_fail;
50527 }
50528 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50529 return resultobj;
50530 fail:
50531 return NULL;
50532 }
50533
50534
50535 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50536 PyObject *resultobj = 0;
50537 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50538 wxSizer *arg2 = (wxSizer *) 0 ;
50539 wxGBPosition result;
50540 void *argp1 = 0 ;
50541 int res1 = 0 ;
50542 void *argp2 = 0 ;
50543 int res2 = 0 ;
50544
50545 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50547 if (!SWIG_IsOK(res1)) {
50548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50549 }
50550 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50551 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50552 if (!SWIG_IsOK(res2)) {
50553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50554 }
50555 arg2 = reinterpret_cast< wxSizer * >(argp2);
50556 {
50557 PyThreadState* __tstate = wxPyBeginAllowThreads();
50558 result = (arg1)->GetItemPosition(arg2);
50559 wxPyEndAllowThreads(__tstate);
50560 if (PyErr_Occurred()) SWIG_fail;
50561 }
50562 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50563 return resultobj;
50564 fail:
50565 return NULL;
50566 }
50567
50568
50569 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50570 PyObject *resultobj = 0;
50571 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50572 size_t arg2 ;
50573 wxGBPosition result;
50574 void *argp1 = 0 ;
50575 int res1 = 0 ;
50576 size_t val2 ;
50577 int ecode2 = 0 ;
50578
50579 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50581 if (!SWIG_IsOK(res1)) {
50582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50583 }
50584 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50585 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50586 if (!SWIG_IsOK(ecode2)) {
50587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50588 }
50589 arg2 = static_cast< size_t >(val2);
50590 {
50591 PyThreadState* __tstate = wxPyBeginAllowThreads();
50592 result = (arg1)->GetItemPosition(arg2);
50593 wxPyEndAllowThreads(__tstate);
50594 if (PyErr_Occurred()) SWIG_fail;
50595 }
50596 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50597 return resultobj;
50598 fail:
50599 return NULL;
50600 }
50601
50602
50603 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50604 int argc;
50605 PyObject *argv[3];
50606
50607 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50608 --argc;
50609 if (argc == 2) {
50610 int _v = 0;
50611 {
50612 void *vptr = 0;
50613 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50614 _v = SWIG_CheckState(res);
50615 }
50616 if (!_v) goto check_1;
50617 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50618 }
50619 check_1:
50620
50621 if (argc == 2) {
50622 int _v = 0;
50623 {
50624 void *vptr = 0;
50625 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50626 _v = SWIG_CheckState(res);
50627 }
50628 if (!_v) goto check_2;
50629 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50630 }
50631 check_2:
50632
50633 if (argc == 2) {
50634 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50635 }
50636
50637 fail:
50638 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50639 return NULL;
50640 }
50641
50642
50643 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50644 PyObject *resultobj = 0;
50645 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50646 wxWindow *arg2 = (wxWindow *) 0 ;
50647 wxGBPosition *arg3 = 0 ;
50648 bool result;
50649 void *argp1 = 0 ;
50650 int res1 = 0 ;
50651 void *argp2 = 0 ;
50652 int res2 = 0 ;
50653 wxGBPosition temp3 ;
50654
50655 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50657 if (!SWIG_IsOK(res1)) {
50658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50659 }
50660 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50661 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50662 if (!SWIG_IsOK(res2)) {
50663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50664 }
50665 arg2 = reinterpret_cast< wxWindow * >(argp2);
50666 {
50667 arg3 = &temp3;
50668 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50669 }
50670 {
50671 PyThreadState* __tstate = wxPyBeginAllowThreads();
50672 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50673 wxPyEndAllowThreads(__tstate);
50674 if (PyErr_Occurred()) SWIG_fail;
50675 }
50676 {
50677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50678 }
50679 return resultobj;
50680 fail:
50681 return NULL;
50682 }
50683
50684
50685 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50686 PyObject *resultobj = 0;
50687 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50688 wxSizer *arg2 = (wxSizer *) 0 ;
50689 wxGBPosition *arg3 = 0 ;
50690 bool result;
50691 void *argp1 = 0 ;
50692 int res1 = 0 ;
50693 void *argp2 = 0 ;
50694 int res2 = 0 ;
50695 wxGBPosition temp3 ;
50696
50697 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50699 if (!SWIG_IsOK(res1)) {
50700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50701 }
50702 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50703 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50704 if (!SWIG_IsOK(res2)) {
50705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50706 }
50707 arg2 = reinterpret_cast< wxSizer * >(argp2);
50708 {
50709 arg3 = &temp3;
50710 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50711 }
50712 {
50713 PyThreadState* __tstate = wxPyBeginAllowThreads();
50714 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50715 wxPyEndAllowThreads(__tstate);
50716 if (PyErr_Occurred()) SWIG_fail;
50717 }
50718 {
50719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50720 }
50721 return resultobj;
50722 fail:
50723 return NULL;
50724 }
50725
50726
50727 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50728 PyObject *resultobj = 0;
50729 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50730 size_t arg2 ;
50731 wxGBPosition *arg3 = 0 ;
50732 bool result;
50733 void *argp1 = 0 ;
50734 int res1 = 0 ;
50735 size_t val2 ;
50736 int ecode2 = 0 ;
50737 wxGBPosition temp3 ;
50738
50739 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50741 if (!SWIG_IsOK(res1)) {
50742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50743 }
50744 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50745 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50746 if (!SWIG_IsOK(ecode2)) {
50747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50748 }
50749 arg2 = static_cast< size_t >(val2);
50750 {
50751 arg3 = &temp3;
50752 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50753 }
50754 {
50755 PyThreadState* __tstate = wxPyBeginAllowThreads();
50756 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50757 wxPyEndAllowThreads(__tstate);
50758 if (PyErr_Occurred()) SWIG_fail;
50759 }
50760 {
50761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50762 }
50763 return resultobj;
50764 fail:
50765 return NULL;
50766 }
50767
50768
50769 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50770 int argc;
50771 PyObject *argv[4];
50772
50773 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50774 --argc;
50775 if (argc == 3) {
50776 int _v = 0;
50777 {
50778 void *vptr = 0;
50779 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50780 _v = SWIG_CheckState(res);
50781 }
50782 if (!_v) goto check_1;
50783 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50784 }
50785 check_1:
50786
50787 if (argc == 3) {
50788 int _v = 0;
50789 {
50790 void *vptr = 0;
50791 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50792 _v = SWIG_CheckState(res);
50793 }
50794 if (!_v) goto check_2;
50795 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50796 }
50797 check_2:
50798
50799 if (argc == 3) {
50800 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50801 }
50802
50803 fail:
50804 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50805 return NULL;
50806 }
50807
50808
50809 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50810 PyObject *resultobj = 0;
50811 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50812 wxWindow *arg2 = (wxWindow *) 0 ;
50813 wxGBSpan result;
50814 void *argp1 = 0 ;
50815 int res1 = 0 ;
50816 void *argp2 = 0 ;
50817 int res2 = 0 ;
50818
50819 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50821 if (!SWIG_IsOK(res1)) {
50822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50823 }
50824 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50825 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50826 if (!SWIG_IsOK(res2)) {
50827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50828 }
50829 arg2 = reinterpret_cast< wxWindow * >(argp2);
50830 {
50831 PyThreadState* __tstate = wxPyBeginAllowThreads();
50832 result = (arg1)->GetItemSpan(arg2);
50833 wxPyEndAllowThreads(__tstate);
50834 if (PyErr_Occurred()) SWIG_fail;
50835 }
50836 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50837 return resultobj;
50838 fail:
50839 return NULL;
50840 }
50841
50842
50843 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50844 PyObject *resultobj = 0;
50845 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50846 wxSizer *arg2 = (wxSizer *) 0 ;
50847 wxGBSpan result;
50848 void *argp1 = 0 ;
50849 int res1 = 0 ;
50850 void *argp2 = 0 ;
50851 int res2 = 0 ;
50852
50853 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50855 if (!SWIG_IsOK(res1)) {
50856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50857 }
50858 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50859 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50860 if (!SWIG_IsOK(res2)) {
50861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50862 }
50863 arg2 = reinterpret_cast< wxSizer * >(argp2);
50864 {
50865 PyThreadState* __tstate = wxPyBeginAllowThreads();
50866 result = (arg1)->GetItemSpan(arg2);
50867 wxPyEndAllowThreads(__tstate);
50868 if (PyErr_Occurred()) SWIG_fail;
50869 }
50870 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50871 return resultobj;
50872 fail:
50873 return NULL;
50874 }
50875
50876
50877 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50878 PyObject *resultobj = 0;
50879 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50880 size_t arg2 ;
50881 wxGBSpan result;
50882 void *argp1 = 0 ;
50883 int res1 = 0 ;
50884 size_t val2 ;
50885 int ecode2 = 0 ;
50886
50887 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50889 if (!SWIG_IsOK(res1)) {
50890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50891 }
50892 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50893 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50894 if (!SWIG_IsOK(ecode2)) {
50895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50896 }
50897 arg2 = static_cast< size_t >(val2);
50898 {
50899 PyThreadState* __tstate = wxPyBeginAllowThreads();
50900 result = (arg1)->GetItemSpan(arg2);
50901 wxPyEndAllowThreads(__tstate);
50902 if (PyErr_Occurred()) SWIG_fail;
50903 }
50904 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50905 return resultobj;
50906 fail:
50907 return NULL;
50908 }
50909
50910
50911 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50912 int argc;
50913 PyObject *argv[3];
50914
50915 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50916 --argc;
50917 if (argc == 2) {
50918 int _v = 0;
50919 {
50920 void *vptr = 0;
50921 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50922 _v = SWIG_CheckState(res);
50923 }
50924 if (!_v) goto check_1;
50925 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50926 }
50927 check_1:
50928
50929 if (argc == 2) {
50930 int _v = 0;
50931 {
50932 void *vptr = 0;
50933 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50934 _v = SWIG_CheckState(res);
50935 }
50936 if (!_v) goto check_2;
50937 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50938 }
50939 check_2:
50940
50941 if (argc == 2) {
50942 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50943 }
50944
50945 fail:
50946 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50947 return NULL;
50948 }
50949
50950
50951 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50952 PyObject *resultobj = 0;
50953 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50954 wxWindow *arg2 = (wxWindow *) 0 ;
50955 wxGBSpan *arg3 = 0 ;
50956 bool result;
50957 void *argp1 = 0 ;
50958 int res1 = 0 ;
50959 void *argp2 = 0 ;
50960 int res2 = 0 ;
50961 wxGBSpan temp3 ;
50962
50963 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50965 if (!SWIG_IsOK(res1)) {
50966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50967 }
50968 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50969 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50970 if (!SWIG_IsOK(res2)) {
50971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50972 }
50973 arg2 = reinterpret_cast< wxWindow * >(argp2);
50974 {
50975 arg3 = &temp3;
50976 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50977 }
50978 {
50979 PyThreadState* __tstate = wxPyBeginAllowThreads();
50980 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50981 wxPyEndAllowThreads(__tstate);
50982 if (PyErr_Occurred()) SWIG_fail;
50983 }
50984 {
50985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50986 }
50987 return resultobj;
50988 fail:
50989 return NULL;
50990 }
50991
50992
50993 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50994 PyObject *resultobj = 0;
50995 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50996 wxSizer *arg2 = (wxSizer *) 0 ;
50997 wxGBSpan *arg3 = 0 ;
50998 bool result;
50999 void *argp1 = 0 ;
51000 int res1 = 0 ;
51001 void *argp2 = 0 ;
51002 int res2 = 0 ;
51003 wxGBSpan temp3 ;
51004
51005 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51007 if (!SWIG_IsOK(res1)) {
51008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51009 }
51010 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51011 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51012 if (!SWIG_IsOK(res2)) {
51013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51014 }
51015 arg2 = reinterpret_cast< wxSizer * >(argp2);
51016 {
51017 arg3 = &temp3;
51018 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51019 }
51020 {
51021 PyThreadState* __tstate = wxPyBeginAllowThreads();
51022 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51023 wxPyEndAllowThreads(__tstate);
51024 if (PyErr_Occurred()) SWIG_fail;
51025 }
51026 {
51027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51028 }
51029 return resultobj;
51030 fail:
51031 return NULL;
51032 }
51033
51034
51035 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51036 PyObject *resultobj = 0;
51037 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51038 size_t arg2 ;
51039 wxGBSpan *arg3 = 0 ;
51040 bool result;
51041 void *argp1 = 0 ;
51042 int res1 = 0 ;
51043 size_t val2 ;
51044 int ecode2 = 0 ;
51045 wxGBSpan temp3 ;
51046
51047 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51049 if (!SWIG_IsOK(res1)) {
51050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51051 }
51052 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51053 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51054 if (!SWIG_IsOK(ecode2)) {
51055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51056 }
51057 arg2 = static_cast< size_t >(val2);
51058 {
51059 arg3 = &temp3;
51060 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51061 }
51062 {
51063 PyThreadState* __tstate = wxPyBeginAllowThreads();
51064 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51065 wxPyEndAllowThreads(__tstate);
51066 if (PyErr_Occurred()) SWIG_fail;
51067 }
51068 {
51069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51070 }
51071 return resultobj;
51072 fail:
51073 return NULL;
51074 }
51075
51076
51077 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51078 int argc;
51079 PyObject *argv[4];
51080
51081 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51082 --argc;
51083 if (argc == 3) {
51084 int _v = 0;
51085 {
51086 void *vptr = 0;
51087 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51088 _v = SWIG_CheckState(res);
51089 }
51090 if (!_v) goto check_1;
51091 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51092 }
51093 check_1:
51094
51095 if (argc == 3) {
51096 int _v = 0;
51097 {
51098 void *vptr = 0;
51099 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51100 _v = SWIG_CheckState(res);
51101 }
51102 if (!_v) goto check_2;
51103 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51104 }
51105 check_2:
51106
51107 if (argc == 3) {
51108 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51109 }
51110
51111 fail:
51112 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51113 return NULL;
51114 }
51115
51116
51117 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51118 PyObject *resultobj = 0;
51119 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51120 wxWindow *arg2 = (wxWindow *) 0 ;
51121 wxGBSizerItem *result = 0 ;
51122 void *argp1 = 0 ;
51123 int res1 = 0 ;
51124 void *argp2 = 0 ;
51125 int res2 = 0 ;
51126
51127 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51129 if (!SWIG_IsOK(res1)) {
51130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51131 }
51132 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51133 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51134 if (!SWIG_IsOK(res2)) {
51135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51136 }
51137 arg2 = reinterpret_cast< wxWindow * >(argp2);
51138 {
51139 PyThreadState* __tstate = wxPyBeginAllowThreads();
51140 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51141 wxPyEndAllowThreads(__tstate);
51142 if (PyErr_Occurred()) SWIG_fail;
51143 }
51144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51145 return resultobj;
51146 fail:
51147 return NULL;
51148 }
51149
51150
51151 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51152 PyObject *resultobj = 0;
51153 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51154 wxSizer *arg2 = (wxSizer *) 0 ;
51155 wxGBSizerItem *result = 0 ;
51156 void *argp1 = 0 ;
51157 int res1 = 0 ;
51158 void *argp2 = 0 ;
51159 int res2 = 0 ;
51160
51161 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51163 if (!SWIG_IsOK(res1)) {
51164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51165 }
51166 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51167 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51168 if (!SWIG_IsOK(res2)) {
51169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51170 }
51171 arg2 = reinterpret_cast< wxSizer * >(argp2);
51172 {
51173 PyThreadState* __tstate = wxPyBeginAllowThreads();
51174 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51175 wxPyEndAllowThreads(__tstate);
51176 if (PyErr_Occurred()) SWIG_fail;
51177 }
51178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51179 return resultobj;
51180 fail:
51181 return NULL;
51182 }
51183
51184
51185 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51186 int argc;
51187 PyObject *argv[3];
51188
51189 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51190 --argc;
51191 if (argc == 2) {
51192 int _v = 0;
51193 {
51194 void *vptr = 0;
51195 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51196 _v = SWIG_CheckState(res);
51197 }
51198 if (!_v) goto check_1;
51199 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51200 }
51201 check_1:
51202
51203 if (argc == 2) {
51204 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51205 }
51206
51207 fail:
51208 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51209 return NULL;
51210 }
51211
51212
51213 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51214 PyObject *resultobj = 0;
51215 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51216 wxGBPosition *arg2 = 0 ;
51217 wxGBSizerItem *result = 0 ;
51218 void *argp1 = 0 ;
51219 int res1 = 0 ;
51220 wxGBPosition temp2 ;
51221 PyObject * obj0 = 0 ;
51222 PyObject * obj1 = 0 ;
51223 char * kwnames[] = {
51224 (char *) "self",(char *) "pos", NULL
51225 };
51226
51227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51229 if (!SWIG_IsOK(res1)) {
51230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51231 }
51232 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51233 {
51234 arg2 = &temp2;
51235 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51236 }
51237 {
51238 PyThreadState* __tstate = wxPyBeginAllowThreads();
51239 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51240 wxPyEndAllowThreads(__tstate);
51241 if (PyErr_Occurred()) SWIG_fail;
51242 }
51243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51244 return resultobj;
51245 fail:
51246 return NULL;
51247 }
51248
51249
51250 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51251 PyObject *resultobj = 0;
51252 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51253 wxPoint *arg2 = 0 ;
51254 wxGBSizerItem *result = 0 ;
51255 void *argp1 = 0 ;
51256 int res1 = 0 ;
51257 wxPoint temp2 ;
51258 PyObject * obj0 = 0 ;
51259 PyObject * obj1 = 0 ;
51260 char * kwnames[] = {
51261 (char *) "self",(char *) "pt", NULL
51262 };
51263
51264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51266 if (!SWIG_IsOK(res1)) {
51267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51268 }
51269 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51270 {
51271 arg2 = &temp2;
51272 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51273 }
51274 {
51275 PyThreadState* __tstate = wxPyBeginAllowThreads();
51276 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51277 wxPyEndAllowThreads(__tstate);
51278 if (PyErr_Occurred()) SWIG_fail;
51279 }
51280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51281 return resultobj;
51282 fail:
51283 return NULL;
51284 }
51285
51286
51287 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51288 PyObject *resultobj = 0;
51289 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51290 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51291 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51292 bool result;
51293 void *argp1 = 0 ;
51294 int res1 = 0 ;
51295 void *argp2 = 0 ;
51296 int res2 = 0 ;
51297 void *argp3 = 0 ;
51298 int res3 = 0 ;
51299 PyObject * obj0 = 0 ;
51300 PyObject * obj1 = 0 ;
51301 PyObject * obj2 = 0 ;
51302 char * kwnames[] = {
51303 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51304 };
51305
51306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51308 if (!SWIG_IsOK(res1)) {
51309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51310 }
51311 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51313 if (!SWIG_IsOK(res2)) {
51314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51315 }
51316 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51317 if (obj2) {
51318 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51319 if (!SWIG_IsOK(res3)) {
51320 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51321 }
51322 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51323 }
51324 {
51325 PyThreadState* __tstate = wxPyBeginAllowThreads();
51326 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51327 wxPyEndAllowThreads(__tstate);
51328 if (PyErr_Occurred()) SWIG_fail;
51329 }
51330 {
51331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51332 }
51333 return resultobj;
51334 fail:
51335 return NULL;
51336 }
51337
51338
51339 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51340 PyObject *resultobj = 0;
51341 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51342 wxGBPosition *arg2 = 0 ;
51343 wxGBSpan *arg3 = 0 ;
51344 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51345 bool result;
51346 void *argp1 = 0 ;
51347 int res1 = 0 ;
51348 wxGBPosition temp2 ;
51349 wxGBSpan temp3 ;
51350 void *argp4 = 0 ;
51351 int res4 = 0 ;
51352 PyObject * obj0 = 0 ;
51353 PyObject * obj1 = 0 ;
51354 PyObject * obj2 = 0 ;
51355 PyObject * obj3 = 0 ;
51356 char * kwnames[] = {
51357 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51358 };
51359
51360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51362 if (!SWIG_IsOK(res1)) {
51363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51364 }
51365 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51366 {
51367 arg2 = &temp2;
51368 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51369 }
51370 {
51371 arg3 = &temp3;
51372 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51373 }
51374 if (obj3) {
51375 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51376 if (!SWIG_IsOK(res4)) {
51377 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51378 }
51379 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51380 }
51381 {
51382 PyThreadState* __tstate = wxPyBeginAllowThreads();
51383 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51384 wxPyEndAllowThreads(__tstate);
51385 if (PyErr_Occurred()) SWIG_fail;
51386 }
51387 {
51388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51389 }
51390 return resultobj;
51391 fail:
51392 return NULL;
51393 }
51394
51395
51396 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51397 PyObject *obj;
51398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51399 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51400 return SWIG_Py_Void();
51401 }
51402
51403 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51404 return SWIG_Python_InitShadowInstance(args);
51405 }
51406
51407 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51408 PyObject *resultobj = 0;
51409 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51410 wxRelationship arg2 ;
51411 wxWindow *arg3 = (wxWindow *) 0 ;
51412 wxEdge arg4 ;
51413 int arg5 = (int) 0 ;
51414 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51415 void *argp1 = 0 ;
51416 int res1 = 0 ;
51417 int val2 ;
51418 int ecode2 = 0 ;
51419 void *argp3 = 0 ;
51420 int res3 = 0 ;
51421 int val4 ;
51422 int ecode4 = 0 ;
51423 int val5 ;
51424 int ecode5 = 0 ;
51425 int val6 ;
51426 int ecode6 = 0 ;
51427 PyObject * obj0 = 0 ;
51428 PyObject * obj1 = 0 ;
51429 PyObject * obj2 = 0 ;
51430 PyObject * obj3 = 0 ;
51431 PyObject * obj4 = 0 ;
51432 PyObject * obj5 = 0 ;
51433 char * kwnames[] = {
51434 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51435 };
51436
51437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51439 if (!SWIG_IsOK(res1)) {
51440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51441 }
51442 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51443 ecode2 = SWIG_AsVal_int(obj1, &val2);
51444 if (!SWIG_IsOK(ecode2)) {
51445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51446 }
51447 arg2 = static_cast< wxRelationship >(val2);
51448 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51449 if (!SWIG_IsOK(res3)) {
51450 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51451 }
51452 arg3 = reinterpret_cast< wxWindow * >(argp3);
51453 ecode4 = SWIG_AsVal_int(obj3, &val4);
51454 if (!SWIG_IsOK(ecode4)) {
51455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51456 }
51457 arg4 = static_cast< wxEdge >(val4);
51458 if (obj4) {
51459 ecode5 = SWIG_AsVal_int(obj4, &val5);
51460 if (!SWIG_IsOK(ecode5)) {
51461 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51462 }
51463 arg5 = static_cast< int >(val5);
51464 }
51465 if (obj5) {
51466 ecode6 = SWIG_AsVal_int(obj5, &val6);
51467 if (!SWIG_IsOK(ecode6)) {
51468 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51469 }
51470 arg6 = static_cast< int >(val6);
51471 }
51472 {
51473 PyThreadState* __tstate = wxPyBeginAllowThreads();
51474 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51475 wxPyEndAllowThreads(__tstate);
51476 if (PyErr_Occurred()) SWIG_fail;
51477 }
51478 resultobj = SWIG_Py_Void();
51479 return resultobj;
51480 fail:
51481 return NULL;
51482 }
51483
51484
51485 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51486 PyObject *resultobj = 0;
51487 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51488 wxWindow *arg2 = (wxWindow *) 0 ;
51489 int arg3 = (int) 0 ;
51490 void *argp1 = 0 ;
51491 int res1 = 0 ;
51492 void *argp2 = 0 ;
51493 int res2 = 0 ;
51494 int val3 ;
51495 int ecode3 = 0 ;
51496 PyObject * obj0 = 0 ;
51497 PyObject * obj1 = 0 ;
51498 PyObject * obj2 = 0 ;
51499 char * kwnames[] = {
51500 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51501 };
51502
51503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51505 if (!SWIG_IsOK(res1)) {
51506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51507 }
51508 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51510 if (!SWIG_IsOK(res2)) {
51511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51512 }
51513 arg2 = reinterpret_cast< wxWindow * >(argp2);
51514 if (obj2) {
51515 ecode3 = SWIG_AsVal_int(obj2, &val3);
51516 if (!SWIG_IsOK(ecode3)) {
51517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51518 }
51519 arg3 = static_cast< int >(val3);
51520 }
51521 {
51522 PyThreadState* __tstate = wxPyBeginAllowThreads();
51523 (arg1)->LeftOf(arg2,arg3);
51524 wxPyEndAllowThreads(__tstate);
51525 if (PyErr_Occurred()) SWIG_fail;
51526 }
51527 resultobj = SWIG_Py_Void();
51528 return resultobj;
51529 fail:
51530 return NULL;
51531 }
51532
51533
51534 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51535 PyObject *resultobj = 0;
51536 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51537 wxWindow *arg2 = (wxWindow *) 0 ;
51538 int arg3 = (int) 0 ;
51539 void *argp1 = 0 ;
51540 int res1 = 0 ;
51541 void *argp2 = 0 ;
51542 int res2 = 0 ;
51543 int val3 ;
51544 int ecode3 = 0 ;
51545 PyObject * obj0 = 0 ;
51546 PyObject * obj1 = 0 ;
51547 PyObject * obj2 = 0 ;
51548 char * kwnames[] = {
51549 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51550 };
51551
51552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51554 if (!SWIG_IsOK(res1)) {
51555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51556 }
51557 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51559 if (!SWIG_IsOK(res2)) {
51560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51561 }
51562 arg2 = reinterpret_cast< wxWindow * >(argp2);
51563 if (obj2) {
51564 ecode3 = SWIG_AsVal_int(obj2, &val3);
51565 if (!SWIG_IsOK(ecode3)) {
51566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51567 }
51568 arg3 = static_cast< int >(val3);
51569 }
51570 {
51571 PyThreadState* __tstate = wxPyBeginAllowThreads();
51572 (arg1)->RightOf(arg2,arg3);
51573 wxPyEndAllowThreads(__tstate);
51574 if (PyErr_Occurred()) SWIG_fail;
51575 }
51576 resultobj = SWIG_Py_Void();
51577 return resultobj;
51578 fail:
51579 return NULL;
51580 }
51581
51582
51583 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51584 PyObject *resultobj = 0;
51585 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51586 wxWindow *arg2 = (wxWindow *) 0 ;
51587 int arg3 = (int) 0 ;
51588 void *argp1 = 0 ;
51589 int res1 = 0 ;
51590 void *argp2 = 0 ;
51591 int res2 = 0 ;
51592 int val3 ;
51593 int ecode3 = 0 ;
51594 PyObject * obj0 = 0 ;
51595 PyObject * obj1 = 0 ;
51596 PyObject * obj2 = 0 ;
51597 char * kwnames[] = {
51598 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51599 };
51600
51601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51603 if (!SWIG_IsOK(res1)) {
51604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51605 }
51606 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51608 if (!SWIG_IsOK(res2)) {
51609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51610 }
51611 arg2 = reinterpret_cast< wxWindow * >(argp2);
51612 if (obj2) {
51613 ecode3 = SWIG_AsVal_int(obj2, &val3);
51614 if (!SWIG_IsOK(ecode3)) {
51615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51616 }
51617 arg3 = static_cast< int >(val3);
51618 }
51619 {
51620 PyThreadState* __tstate = wxPyBeginAllowThreads();
51621 (arg1)->Above(arg2,arg3);
51622 wxPyEndAllowThreads(__tstate);
51623 if (PyErr_Occurred()) SWIG_fail;
51624 }
51625 resultobj = SWIG_Py_Void();
51626 return resultobj;
51627 fail:
51628 return NULL;
51629 }
51630
51631
51632 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51633 PyObject *resultobj = 0;
51634 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51635 wxWindow *arg2 = (wxWindow *) 0 ;
51636 int arg3 = (int) 0 ;
51637 void *argp1 = 0 ;
51638 int res1 = 0 ;
51639 void *argp2 = 0 ;
51640 int res2 = 0 ;
51641 int val3 ;
51642 int ecode3 = 0 ;
51643 PyObject * obj0 = 0 ;
51644 PyObject * obj1 = 0 ;
51645 PyObject * obj2 = 0 ;
51646 char * kwnames[] = {
51647 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51648 };
51649
51650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51652 if (!SWIG_IsOK(res1)) {
51653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51654 }
51655 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51656 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51657 if (!SWIG_IsOK(res2)) {
51658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51659 }
51660 arg2 = reinterpret_cast< wxWindow * >(argp2);
51661 if (obj2) {
51662 ecode3 = SWIG_AsVal_int(obj2, &val3);
51663 if (!SWIG_IsOK(ecode3)) {
51664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51665 }
51666 arg3 = static_cast< int >(val3);
51667 }
51668 {
51669 PyThreadState* __tstate = wxPyBeginAllowThreads();
51670 (arg1)->Below(arg2,arg3);
51671 wxPyEndAllowThreads(__tstate);
51672 if (PyErr_Occurred()) SWIG_fail;
51673 }
51674 resultobj = SWIG_Py_Void();
51675 return resultobj;
51676 fail:
51677 return NULL;
51678 }
51679
51680
51681 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51682 PyObject *resultobj = 0;
51683 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51684 wxWindow *arg2 = (wxWindow *) 0 ;
51685 wxEdge arg3 ;
51686 int arg4 = (int) 0 ;
51687 void *argp1 = 0 ;
51688 int res1 = 0 ;
51689 void *argp2 = 0 ;
51690 int res2 = 0 ;
51691 int val3 ;
51692 int ecode3 = 0 ;
51693 int val4 ;
51694 int ecode4 = 0 ;
51695 PyObject * obj0 = 0 ;
51696 PyObject * obj1 = 0 ;
51697 PyObject * obj2 = 0 ;
51698 PyObject * obj3 = 0 ;
51699 char * kwnames[] = {
51700 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51701 };
51702
51703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51705 if (!SWIG_IsOK(res1)) {
51706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51707 }
51708 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51710 if (!SWIG_IsOK(res2)) {
51711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51712 }
51713 arg2 = reinterpret_cast< wxWindow * >(argp2);
51714 ecode3 = SWIG_AsVal_int(obj2, &val3);
51715 if (!SWIG_IsOK(ecode3)) {
51716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51717 }
51718 arg3 = static_cast< wxEdge >(val3);
51719 if (obj3) {
51720 ecode4 = SWIG_AsVal_int(obj3, &val4);
51721 if (!SWIG_IsOK(ecode4)) {
51722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51723 }
51724 arg4 = static_cast< int >(val4);
51725 }
51726 {
51727 PyThreadState* __tstate = wxPyBeginAllowThreads();
51728 (arg1)->SameAs(arg2,arg3,arg4);
51729 wxPyEndAllowThreads(__tstate);
51730 if (PyErr_Occurred()) SWIG_fail;
51731 }
51732 resultobj = SWIG_Py_Void();
51733 return resultobj;
51734 fail:
51735 return NULL;
51736 }
51737
51738
51739 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51740 PyObject *resultobj = 0;
51741 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51742 wxWindow *arg2 = (wxWindow *) 0 ;
51743 wxEdge arg3 ;
51744 int arg4 ;
51745 void *argp1 = 0 ;
51746 int res1 = 0 ;
51747 void *argp2 = 0 ;
51748 int res2 = 0 ;
51749 int val3 ;
51750 int ecode3 = 0 ;
51751 int val4 ;
51752 int ecode4 = 0 ;
51753 PyObject * obj0 = 0 ;
51754 PyObject * obj1 = 0 ;
51755 PyObject * obj2 = 0 ;
51756 PyObject * obj3 = 0 ;
51757 char * kwnames[] = {
51758 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51759 };
51760
51761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51763 if (!SWIG_IsOK(res1)) {
51764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51765 }
51766 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51768 if (!SWIG_IsOK(res2)) {
51769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51770 }
51771 arg2 = reinterpret_cast< wxWindow * >(argp2);
51772 ecode3 = SWIG_AsVal_int(obj2, &val3);
51773 if (!SWIG_IsOK(ecode3)) {
51774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51775 }
51776 arg3 = static_cast< wxEdge >(val3);
51777 ecode4 = SWIG_AsVal_int(obj3, &val4);
51778 if (!SWIG_IsOK(ecode4)) {
51779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51780 }
51781 arg4 = static_cast< int >(val4);
51782 {
51783 PyThreadState* __tstate = wxPyBeginAllowThreads();
51784 (arg1)->PercentOf(arg2,arg3,arg4);
51785 wxPyEndAllowThreads(__tstate);
51786 if (PyErr_Occurred()) SWIG_fail;
51787 }
51788 resultobj = SWIG_Py_Void();
51789 return resultobj;
51790 fail:
51791 return NULL;
51792 }
51793
51794
51795 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51796 PyObject *resultobj = 0;
51797 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51798 int arg2 ;
51799 void *argp1 = 0 ;
51800 int res1 = 0 ;
51801 int val2 ;
51802 int ecode2 = 0 ;
51803 PyObject * obj0 = 0 ;
51804 PyObject * obj1 = 0 ;
51805 char * kwnames[] = {
51806 (char *) "self",(char *) "val", NULL
51807 };
51808
51809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51811 if (!SWIG_IsOK(res1)) {
51812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51813 }
51814 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51815 ecode2 = SWIG_AsVal_int(obj1, &val2);
51816 if (!SWIG_IsOK(ecode2)) {
51817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51818 }
51819 arg2 = static_cast< int >(val2);
51820 {
51821 PyThreadState* __tstate = wxPyBeginAllowThreads();
51822 (arg1)->Absolute(arg2);
51823 wxPyEndAllowThreads(__tstate);
51824 if (PyErr_Occurred()) SWIG_fail;
51825 }
51826 resultobj = SWIG_Py_Void();
51827 return resultobj;
51828 fail:
51829 return NULL;
51830 }
51831
51832
51833 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51834 PyObject *resultobj = 0;
51835 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51836 void *argp1 = 0 ;
51837 int res1 = 0 ;
51838 PyObject *swig_obj[1] ;
51839
51840 if (!args) SWIG_fail;
51841 swig_obj[0] = args;
51842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51843 if (!SWIG_IsOK(res1)) {
51844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51845 }
51846 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51847 {
51848 PyThreadState* __tstate = wxPyBeginAllowThreads();
51849 (arg1)->Unconstrained();
51850 wxPyEndAllowThreads(__tstate);
51851 if (PyErr_Occurred()) SWIG_fail;
51852 }
51853 resultobj = SWIG_Py_Void();
51854 return resultobj;
51855 fail:
51856 return NULL;
51857 }
51858
51859
51860 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51861 PyObject *resultobj = 0;
51862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51863 void *argp1 = 0 ;
51864 int res1 = 0 ;
51865 PyObject *swig_obj[1] ;
51866
51867 if (!args) SWIG_fail;
51868 swig_obj[0] = args;
51869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51870 if (!SWIG_IsOK(res1)) {
51871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51872 }
51873 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51874 {
51875 PyThreadState* __tstate = wxPyBeginAllowThreads();
51876 (arg1)->AsIs();
51877 wxPyEndAllowThreads(__tstate);
51878 if (PyErr_Occurred()) SWIG_fail;
51879 }
51880 resultobj = SWIG_Py_Void();
51881 return resultobj;
51882 fail:
51883 return NULL;
51884 }
51885
51886
51887 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51888 PyObject *resultobj = 0;
51889 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51890 wxWindow *result = 0 ;
51891 void *argp1 = 0 ;
51892 int res1 = 0 ;
51893 PyObject *swig_obj[1] ;
51894
51895 if (!args) SWIG_fail;
51896 swig_obj[0] = args;
51897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51898 if (!SWIG_IsOK(res1)) {
51899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51900 }
51901 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51902 {
51903 PyThreadState* __tstate = wxPyBeginAllowThreads();
51904 result = (wxWindow *)(arg1)->GetOtherWindow();
51905 wxPyEndAllowThreads(__tstate);
51906 if (PyErr_Occurred()) SWIG_fail;
51907 }
51908 {
51909 resultobj = wxPyMake_wxObject(result, 0);
51910 }
51911 return resultobj;
51912 fail:
51913 return NULL;
51914 }
51915
51916
51917 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51918 PyObject *resultobj = 0;
51919 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51920 wxEdge result;
51921 void *argp1 = 0 ;
51922 int res1 = 0 ;
51923 PyObject *swig_obj[1] ;
51924
51925 if (!args) SWIG_fail;
51926 swig_obj[0] = args;
51927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51928 if (!SWIG_IsOK(res1)) {
51929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51930 }
51931 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51932 {
51933 PyThreadState* __tstate = wxPyBeginAllowThreads();
51934 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51935 wxPyEndAllowThreads(__tstate);
51936 if (PyErr_Occurred()) SWIG_fail;
51937 }
51938 resultobj = SWIG_From_int(static_cast< int >(result));
51939 return resultobj;
51940 fail:
51941 return NULL;
51942 }
51943
51944
51945 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51946 PyObject *resultobj = 0;
51947 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51948 wxEdge arg2 ;
51949 void *argp1 = 0 ;
51950 int res1 = 0 ;
51951 int val2 ;
51952 int ecode2 = 0 ;
51953 PyObject * obj0 = 0 ;
51954 PyObject * obj1 = 0 ;
51955 char * kwnames[] = {
51956 (char *) "self",(char *) "which", NULL
51957 };
51958
51959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51961 if (!SWIG_IsOK(res1)) {
51962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51963 }
51964 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51965 ecode2 = SWIG_AsVal_int(obj1, &val2);
51966 if (!SWIG_IsOK(ecode2)) {
51967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51968 }
51969 arg2 = static_cast< wxEdge >(val2);
51970 {
51971 PyThreadState* __tstate = wxPyBeginAllowThreads();
51972 (arg1)->SetEdge(arg2);
51973 wxPyEndAllowThreads(__tstate);
51974 if (PyErr_Occurred()) SWIG_fail;
51975 }
51976 resultobj = SWIG_Py_Void();
51977 return resultobj;
51978 fail:
51979 return NULL;
51980 }
51981
51982
51983 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51984 PyObject *resultobj = 0;
51985 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51986 int arg2 ;
51987 void *argp1 = 0 ;
51988 int res1 = 0 ;
51989 int val2 ;
51990 int ecode2 = 0 ;
51991 PyObject * obj0 = 0 ;
51992 PyObject * obj1 = 0 ;
51993 char * kwnames[] = {
51994 (char *) "self",(char *) "v", NULL
51995 };
51996
51997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51999 if (!SWIG_IsOK(res1)) {
52000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52001 }
52002 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52003 ecode2 = SWIG_AsVal_int(obj1, &val2);
52004 if (!SWIG_IsOK(ecode2)) {
52005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52006 }
52007 arg2 = static_cast< int >(val2);
52008 {
52009 PyThreadState* __tstate = wxPyBeginAllowThreads();
52010 (arg1)->SetValue(arg2);
52011 wxPyEndAllowThreads(__tstate);
52012 if (PyErr_Occurred()) SWIG_fail;
52013 }
52014 resultobj = SWIG_Py_Void();
52015 return resultobj;
52016 fail:
52017 return NULL;
52018 }
52019
52020
52021 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52022 PyObject *resultobj = 0;
52023 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52024 int result;
52025 void *argp1 = 0 ;
52026 int res1 = 0 ;
52027 PyObject *swig_obj[1] ;
52028
52029 if (!args) SWIG_fail;
52030 swig_obj[0] = args;
52031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52032 if (!SWIG_IsOK(res1)) {
52033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52034 }
52035 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52036 {
52037 PyThreadState* __tstate = wxPyBeginAllowThreads();
52038 result = (int)(arg1)->GetMargin();
52039 wxPyEndAllowThreads(__tstate);
52040 if (PyErr_Occurred()) SWIG_fail;
52041 }
52042 resultobj = SWIG_From_int(static_cast< int >(result));
52043 return resultobj;
52044 fail:
52045 return NULL;
52046 }
52047
52048
52049 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52050 PyObject *resultobj = 0;
52051 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52052 int arg2 ;
52053 void *argp1 = 0 ;
52054 int res1 = 0 ;
52055 int val2 ;
52056 int ecode2 = 0 ;
52057 PyObject * obj0 = 0 ;
52058 PyObject * obj1 = 0 ;
52059 char * kwnames[] = {
52060 (char *) "self",(char *) "m", NULL
52061 };
52062
52063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52065 if (!SWIG_IsOK(res1)) {
52066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52067 }
52068 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52069 ecode2 = SWIG_AsVal_int(obj1, &val2);
52070 if (!SWIG_IsOK(ecode2)) {
52071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52072 }
52073 arg2 = static_cast< int >(val2);
52074 {
52075 PyThreadState* __tstate = wxPyBeginAllowThreads();
52076 (arg1)->SetMargin(arg2);
52077 wxPyEndAllowThreads(__tstate);
52078 if (PyErr_Occurred()) SWIG_fail;
52079 }
52080 resultobj = SWIG_Py_Void();
52081 return resultobj;
52082 fail:
52083 return NULL;
52084 }
52085
52086
52087 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52088 PyObject *resultobj = 0;
52089 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52090 int result;
52091 void *argp1 = 0 ;
52092 int res1 = 0 ;
52093 PyObject *swig_obj[1] ;
52094
52095 if (!args) SWIG_fail;
52096 swig_obj[0] = args;
52097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52098 if (!SWIG_IsOK(res1)) {
52099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52100 }
52101 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52102 {
52103 PyThreadState* __tstate = wxPyBeginAllowThreads();
52104 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52105 wxPyEndAllowThreads(__tstate);
52106 if (PyErr_Occurred()) SWIG_fail;
52107 }
52108 resultobj = SWIG_From_int(static_cast< int >(result));
52109 return resultobj;
52110 fail:
52111 return NULL;
52112 }
52113
52114
52115 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52116 PyObject *resultobj = 0;
52117 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52118 int result;
52119 void *argp1 = 0 ;
52120 int res1 = 0 ;
52121 PyObject *swig_obj[1] ;
52122
52123 if (!args) SWIG_fail;
52124 swig_obj[0] = args;
52125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52126 if (!SWIG_IsOK(res1)) {
52127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52128 }
52129 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52130 {
52131 PyThreadState* __tstate = wxPyBeginAllowThreads();
52132 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52133 wxPyEndAllowThreads(__tstate);
52134 if (PyErr_Occurred()) SWIG_fail;
52135 }
52136 resultobj = SWIG_From_int(static_cast< int >(result));
52137 return resultobj;
52138 fail:
52139 return NULL;
52140 }
52141
52142
52143 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52144 PyObject *resultobj = 0;
52145 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52146 int result;
52147 void *argp1 = 0 ;
52148 int res1 = 0 ;
52149 PyObject *swig_obj[1] ;
52150
52151 if (!args) SWIG_fail;
52152 swig_obj[0] = args;
52153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52154 if (!SWIG_IsOK(res1)) {
52155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52156 }
52157 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52158 {
52159 PyThreadState* __tstate = wxPyBeginAllowThreads();
52160 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52161 wxPyEndAllowThreads(__tstate);
52162 if (PyErr_Occurred()) SWIG_fail;
52163 }
52164 resultobj = SWIG_From_int(static_cast< int >(result));
52165 return resultobj;
52166 fail:
52167 return NULL;
52168 }
52169
52170
52171 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52172 PyObject *resultobj = 0;
52173 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52174 bool result;
52175 void *argp1 = 0 ;
52176 int res1 = 0 ;
52177 PyObject *swig_obj[1] ;
52178
52179 if (!args) SWIG_fail;
52180 swig_obj[0] = args;
52181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52182 if (!SWIG_IsOK(res1)) {
52183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52184 }
52185 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52186 {
52187 PyThreadState* __tstate = wxPyBeginAllowThreads();
52188 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52189 wxPyEndAllowThreads(__tstate);
52190 if (PyErr_Occurred()) SWIG_fail;
52191 }
52192 {
52193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52194 }
52195 return resultobj;
52196 fail:
52197 return NULL;
52198 }
52199
52200
52201 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52202 PyObject *resultobj = 0;
52203 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52204 bool arg2 ;
52205 void *argp1 = 0 ;
52206 int res1 = 0 ;
52207 bool val2 ;
52208 int ecode2 = 0 ;
52209 PyObject * obj0 = 0 ;
52210 PyObject * obj1 = 0 ;
52211 char * kwnames[] = {
52212 (char *) "self",(char *) "d", NULL
52213 };
52214
52215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52217 if (!SWIG_IsOK(res1)) {
52218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52219 }
52220 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52221 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52222 if (!SWIG_IsOK(ecode2)) {
52223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52224 }
52225 arg2 = static_cast< bool >(val2);
52226 {
52227 PyThreadState* __tstate = wxPyBeginAllowThreads();
52228 (arg1)->SetDone(arg2);
52229 wxPyEndAllowThreads(__tstate);
52230 if (PyErr_Occurred()) SWIG_fail;
52231 }
52232 resultobj = SWIG_Py_Void();
52233 return resultobj;
52234 fail:
52235 return NULL;
52236 }
52237
52238
52239 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52240 PyObject *resultobj = 0;
52241 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52242 wxRelationship result;
52243 void *argp1 = 0 ;
52244 int res1 = 0 ;
52245 PyObject *swig_obj[1] ;
52246
52247 if (!args) SWIG_fail;
52248 swig_obj[0] = args;
52249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52250 if (!SWIG_IsOK(res1)) {
52251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52252 }
52253 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52254 {
52255 PyThreadState* __tstate = wxPyBeginAllowThreads();
52256 result = (wxRelationship)(arg1)->GetRelationship();
52257 wxPyEndAllowThreads(__tstate);
52258 if (PyErr_Occurred()) SWIG_fail;
52259 }
52260 resultobj = SWIG_From_int(static_cast< int >(result));
52261 return resultobj;
52262 fail:
52263 return NULL;
52264 }
52265
52266
52267 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52268 PyObject *resultobj = 0;
52269 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52270 wxRelationship arg2 ;
52271 void *argp1 = 0 ;
52272 int res1 = 0 ;
52273 int val2 ;
52274 int ecode2 = 0 ;
52275 PyObject * obj0 = 0 ;
52276 PyObject * obj1 = 0 ;
52277 char * kwnames[] = {
52278 (char *) "self",(char *) "r", NULL
52279 };
52280
52281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52283 if (!SWIG_IsOK(res1)) {
52284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52285 }
52286 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52287 ecode2 = SWIG_AsVal_int(obj1, &val2);
52288 if (!SWIG_IsOK(ecode2)) {
52289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52290 }
52291 arg2 = static_cast< wxRelationship >(val2);
52292 {
52293 PyThreadState* __tstate = wxPyBeginAllowThreads();
52294 (arg1)->SetRelationship(arg2);
52295 wxPyEndAllowThreads(__tstate);
52296 if (PyErr_Occurred()) SWIG_fail;
52297 }
52298 resultobj = SWIG_Py_Void();
52299 return resultobj;
52300 fail:
52301 return NULL;
52302 }
52303
52304
52305 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52306 PyObject *resultobj = 0;
52307 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52308 wxWindow *arg2 = (wxWindow *) 0 ;
52309 bool result;
52310 void *argp1 = 0 ;
52311 int res1 = 0 ;
52312 void *argp2 = 0 ;
52313 int res2 = 0 ;
52314 PyObject * obj0 = 0 ;
52315 PyObject * obj1 = 0 ;
52316 char * kwnames[] = {
52317 (char *) "self",(char *) "otherW", NULL
52318 };
52319
52320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52322 if (!SWIG_IsOK(res1)) {
52323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52324 }
52325 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52327 if (!SWIG_IsOK(res2)) {
52328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52329 }
52330 arg2 = reinterpret_cast< wxWindow * >(argp2);
52331 {
52332 PyThreadState* __tstate = wxPyBeginAllowThreads();
52333 result = (bool)(arg1)->ResetIfWin(arg2);
52334 wxPyEndAllowThreads(__tstate);
52335 if (PyErr_Occurred()) SWIG_fail;
52336 }
52337 {
52338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52339 }
52340 return resultobj;
52341 fail:
52342 return NULL;
52343 }
52344
52345
52346 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52347 PyObject *resultobj = 0;
52348 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52349 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52350 wxWindow *arg3 = (wxWindow *) 0 ;
52351 bool result;
52352 void *argp1 = 0 ;
52353 int res1 = 0 ;
52354 void *argp2 = 0 ;
52355 int res2 = 0 ;
52356 void *argp3 = 0 ;
52357 int res3 = 0 ;
52358 PyObject * obj0 = 0 ;
52359 PyObject * obj1 = 0 ;
52360 PyObject * obj2 = 0 ;
52361 char * kwnames[] = {
52362 (char *) "self",(char *) "constraints",(char *) "win", NULL
52363 };
52364
52365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52367 if (!SWIG_IsOK(res1)) {
52368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52369 }
52370 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52371 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52372 if (!SWIG_IsOK(res2)) {
52373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52374 }
52375 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52376 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52377 if (!SWIG_IsOK(res3)) {
52378 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52379 }
52380 arg3 = reinterpret_cast< wxWindow * >(argp3);
52381 {
52382 PyThreadState* __tstate = wxPyBeginAllowThreads();
52383 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52384 wxPyEndAllowThreads(__tstate);
52385 if (PyErr_Occurred()) SWIG_fail;
52386 }
52387 {
52388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52389 }
52390 return resultobj;
52391 fail:
52392 return NULL;
52393 }
52394
52395
52396 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52397 PyObject *resultobj = 0;
52398 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52399 wxEdge arg2 ;
52400 wxWindow *arg3 = (wxWindow *) 0 ;
52401 wxWindow *arg4 = (wxWindow *) 0 ;
52402 int result;
52403 void *argp1 = 0 ;
52404 int res1 = 0 ;
52405 int val2 ;
52406 int ecode2 = 0 ;
52407 void *argp3 = 0 ;
52408 int res3 = 0 ;
52409 void *argp4 = 0 ;
52410 int res4 = 0 ;
52411 PyObject * obj0 = 0 ;
52412 PyObject * obj1 = 0 ;
52413 PyObject * obj2 = 0 ;
52414 PyObject * obj3 = 0 ;
52415 char * kwnames[] = {
52416 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52417 };
52418
52419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52421 if (!SWIG_IsOK(res1)) {
52422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52423 }
52424 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52425 ecode2 = SWIG_AsVal_int(obj1, &val2);
52426 if (!SWIG_IsOK(ecode2)) {
52427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52428 }
52429 arg2 = static_cast< wxEdge >(val2);
52430 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52431 if (!SWIG_IsOK(res3)) {
52432 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52433 }
52434 arg3 = reinterpret_cast< wxWindow * >(argp3);
52435 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52436 if (!SWIG_IsOK(res4)) {
52437 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52438 }
52439 arg4 = reinterpret_cast< wxWindow * >(argp4);
52440 {
52441 PyThreadState* __tstate = wxPyBeginAllowThreads();
52442 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52443 wxPyEndAllowThreads(__tstate);
52444 if (PyErr_Occurred()) SWIG_fail;
52445 }
52446 resultobj = SWIG_From_int(static_cast< int >(result));
52447 return resultobj;
52448 fail:
52449 return NULL;
52450 }
52451
52452
52453 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52454 PyObject *obj;
52455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52456 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52457 return SWIG_Py_Void();
52458 }
52459
52460 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52461 PyObject *resultobj = 0;
52462 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52463 wxIndividualLayoutConstraint *result = 0 ;
52464 void *argp1 = 0 ;
52465 int res1 = 0 ;
52466 PyObject *swig_obj[1] ;
52467
52468 if (!args) SWIG_fail;
52469 swig_obj[0] = args;
52470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52471 if (!SWIG_IsOK(res1)) {
52472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52473 }
52474 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52475 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52477 return resultobj;
52478 fail:
52479 return NULL;
52480 }
52481
52482
52483 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52484 PyObject *resultobj = 0;
52485 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52486 wxIndividualLayoutConstraint *result = 0 ;
52487 void *argp1 = 0 ;
52488 int res1 = 0 ;
52489 PyObject *swig_obj[1] ;
52490
52491 if (!args) SWIG_fail;
52492 swig_obj[0] = args;
52493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52494 if (!SWIG_IsOK(res1)) {
52495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52496 }
52497 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52498 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52500 return resultobj;
52501 fail:
52502 return NULL;
52503 }
52504
52505
52506 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52507 PyObject *resultobj = 0;
52508 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52509 wxIndividualLayoutConstraint *result = 0 ;
52510 void *argp1 = 0 ;
52511 int res1 = 0 ;
52512 PyObject *swig_obj[1] ;
52513
52514 if (!args) SWIG_fail;
52515 swig_obj[0] = args;
52516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52517 if (!SWIG_IsOK(res1)) {
52518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52519 }
52520 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52521 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52523 return resultobj;
52524 fail:
52525 return NULL;
52526 }
52527
52528
52529 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52530 PyObject *resultobj = 0;
52531 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52532 wxIndividualLayoutConstraint *result = 0 ;
52533 void *argp1 = 0 ;
52534 int res1 = 0 ;
52535 PyObject *swig_obj[1] ;
52536
52537 if (!args) SWIG_fail;
52538 swig_obj[0] = args;
52539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52540 if (!SWIG_IsOK(res1)) {
52541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52542 }
52543 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52544 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52546 return resultobj;
52547 fail:
52548 return NULL;
52549 }
52550
52551
52552 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52553 PyObject *resultobj = 0;
52554 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52555 wxIndividualLayoutConstraint *result = 0 ;
52556 void *argp1 = 0 ;
52557 int res1 = 0 ;
52558 PyObject *swig_obj[1] ;
52559
52560 if (!args) SWIG_fail;
52561 swig_obj[0] = args;
52562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52563 if (!SWIG_IsOK(res1)) {
52564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52565 }
52566 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52567 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52569 return resultobj;
52570 fail:
52571 return NULL;
52572 }
52573
52574
52575 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52576 PyObject *resultobj = 0;
52577 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52578 wxIndividualLayoutConstraint *result = 0 ;
52579 void *argp1 = 0 ;
52580 int res1 = 0 ;
52581 PyObject *swig_obj[1] ;
52582
52583 if (!args) SWIG_fail;
52584 swig_obj[0] = args;
52585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52586 if (!SWIG_IsOK(res1)) {
52587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52588 }
52589 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52590 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52592 return resultobj;
52593 fail:
52594 return NULL;
52595 }
52596
52597
52598 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52599 PyObject *resultobj = 0;
52600 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52601 wxIndividualLayoutConstraint *result = 0 ;
52602 void *argp1 = 0 ;
52603 int res1 = 0 ;
52604 PyObject *swig_obj[1] ;
52605
52606 if (!args) SWIG_fail;
52607 swig_obj[0] = args;
52608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52609 if (!SWIG_IsOK(res1)) {
52610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52611 }
52612 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52613 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52615 return resultobj;
52616 fail:
52617 return NULL;
52618 }
52619
52620
52621 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52622 PyObject *resultobj = 0;
52623 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52624 wxIndividualLayoutConstraint *result = 0 ;
52625 void *argp1 = 0 ;
52626 int res1 = 0 ;
52627 PyObject *swig_obj[1] ;
52628
52629 if (!args) SWIG_fail;
52630 swig_obj[0] = args;
52631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52632 if (!SWIG_IsOK(res1)) {
52633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52634 }
52635 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52636 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52638 return resultobj;
52639 fail:
52640 return NULL;
52641 }
52642
52643
52644 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52645 PyObject *resultobj = 0;
52646 wxLayoutConstraints *result = 0 ;
52647
52648 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52649 {
52650 PyThreadState* __tstate = wxPyBeginAllowThreads();
52651 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52652 wxPyEndAllowThreads(__tstate);
52653 if (PyErr_Occurred()) SWIG_fail;
52654 }
52655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52656 return resultobj;
52657 fail:
52658 return NULL;
52659 }
52660
52661
52662 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52663 PyObject *resultobj = 0;
52664 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52665 void *argp1 = 0 ;
52666 int res1 = 0 ;
52667 PyObject *swig_obj[1] ;
52668
52669 if (!args) SWIG_fail;
52670 swig_obj[0] = args;
52671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52672 if (!SWIG_IsOK(res1)) {
52673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52674 }
52675 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52676 {
52677 PyThreadState* __tstate = wxPyBeginAllowThreads();
52678 delete arg1;
52679
52680 wxPyEndAllowThreads(__tstate);
52681 if (PyErr_Occurred()) SWIG_fail;
52682 }
52683 resultobj = SWIG_Py_Void();
52684 return resultobj;
52685 fail:
52686 return NULL;
52687 }
52688
52689
52690 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52691 PyObject *resultobj = 0;
52692 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52693 wxWindow *arg2 = (wxWindow *) 0 ;
52694 int *arg3 = (int *) 0 ;
52695 bool result;
52696 void *argp1 = 0 ;
52697 int res1 = 0 ;
52698 void *argp2 = 0 ;
52699 int res2 = 0 ;
52700 int temp3 ;
52701 int res3 = SWIG_TMPOBJ ;
52702 PyObject * obj0 = 0 ;
52703 PyObject * obj1 = 0 ;
52704 char * kwnames[] = {
52705 (char *) "self",(char *) "win", NULL
52706 };
52707
52708 arg3 = &temp3;
52709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52711 if (!SWIG_IsOK(res1)) {
52712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52713 }
52714 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52715 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52716 if (!SWIG_IsOK(res2)) {
52717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52718 }
52719 arg2 = reinterpret_cast< wxWindow * >(argp2);
52720 {
52721 PyThreadState* __tstate = wxPyBeginAllowThreads();
52722 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52723 wxPyEndAllowThreads(__tstate);
52724 if (PyErr_Occurred()) SWIG_fail;
52725 }
52726 {
52727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52728 }
52729 if (SWIG_IsTmpObj(res3)) {
52730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52731 } else {
52732 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52734 }
52735 return resultobj;
52736 fail:
52737 return NULL;
52738 }
52739
52740
52741 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52742 PyObject *resultobj = 0;
52743 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52744 bool result;
52745 void *argp1 = 0 ;
52746 int res1 = 0 ;
52747 PyObject *swig_obj[1] ;
52748
52749 if (!args) SWIG_fail;
52750 swig_obj[0] = args;
52751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52752 if (!SWIG_IsOK(res1)) {
52753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52754 }
52755 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52756 {
52757 PyThreadState* __tstate = wxPyBeginAllowThreads();
52758 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52759 wxPyEndAllowThreads(__tstate);
52760 if (PyErr_Occurred()) SWIG_fail;
52761 }
52762 {
52763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52764 }
52765 return resultobj;
52766 fail:
52767 return NULL;
52768 }
52769
52770
52771 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52772 PyObject *obj;
52773 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52774 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52775 return SWIG_Py_Void();
52776 }
52777
52778 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52779 return SWIG_Python_InitShadowInstance(args);
52780 }
52781
52782 static PyMethodDef SwigMethods[] = {
52783 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52784 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52785 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52786 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52787 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52788 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52789 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52790 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52791 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52793 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52803 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52804 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52805 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52807 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52808 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52809 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52810 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52811 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52812 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52813 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52815 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52821 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52822 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52823 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52824 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52825 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52826 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52827 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52829 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52837 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52838 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52839 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52844 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52845 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52847 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52849 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52851 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52853 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52855 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52857 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52858 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52860 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52862 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52863 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52864 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52865 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52884 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52885 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52886 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52887 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52888 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52889 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52890 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52891 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52893 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52894 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52895 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52900 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52901 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52902 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52903 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52910 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52917 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52918 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52919 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52920 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52922 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52923 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52924 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52926 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52927 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52928 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52929 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52934 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52935 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52936 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52937 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52938 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52939 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52942 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52943 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52944 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52946 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52947 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52949 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52950 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52951 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52952 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52953 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52954 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52955 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52956 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52957 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52958 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52959 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52964 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52970 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52971 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52972 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52973 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52975 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52978 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52980 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52983 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52984 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52985 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52988 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52989 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52990 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52994 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52995 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52996 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53000 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53005 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53006 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53007 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53008 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53009 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53010 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53011 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53018 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53019 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53021 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53022 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53023 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53029 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53030 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53032 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53033 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53034 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53035 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53036 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53037 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53038 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53039 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53041 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53042 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53043 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53044 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53045 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53046 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53047 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53048 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53050 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53059 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53071 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53072 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53087 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53088 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53089 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53090 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53093 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53095 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53097 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53099 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53101 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53104 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53105 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53106 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53107 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53109 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53126 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53127 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53133 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53134 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53135 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53136 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53137 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53138 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53139 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53140 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53141 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53142 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53143 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53144 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53145 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53146 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53147 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53148 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53149 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53150 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53151 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53152 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53153 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53154 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53155 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53156 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53157 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53158 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53159 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53160 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53161 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53162 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53163 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53164 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53165 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53166 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53167 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53169 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53170 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53171 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53172 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53175 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53179 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53183 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53184 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53185 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53186 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53188 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53189 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53191 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53193 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53195 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53197 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53198 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53199 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53201 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53202 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53203 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53204 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53205 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53206 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53208 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53209 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53210 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53212 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53214 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53215 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53216 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53218 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53220 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53221 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53223 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53224 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53225 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53227 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53228 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53229 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53230 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53231 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53233 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53234 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53237 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53238 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53240 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53241 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53244 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53245 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53247 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53253 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53254 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53255 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53256 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53257 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53258 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53259 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53260 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53261 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53262 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53263 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53264 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53265 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53266 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53267 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53268 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53269 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53270 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53271 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53272 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53273 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53274 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53275 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53276 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53278 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53279 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53280 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53281 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53282 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53283 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53284 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53285 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53286 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53287 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53288 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53289 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53290 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53291 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53292 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53293 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53294 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53295 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53296 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53297 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53298 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53299 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53300 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53301 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53302 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53303 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53304 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53305 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53306 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53307 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53308 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53309 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53311 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53312 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53314 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53315 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53316 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53317 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53319 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53320 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53321 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53322 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53323 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53324 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53325 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53326 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53327 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53329 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53330 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53331 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53332 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53333 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53334 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53335 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53336 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53337 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53338 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53339 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53340 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53341 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53342 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53343 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53344 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53345 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53346 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53347 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53348 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53349 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53350 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53351 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53352 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53353 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53354 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53355 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53356 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53358 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53359 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53362 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53363 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53364 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53365 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53366 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53367 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53369 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53370 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53373 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53374 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53376 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53377 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53379 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53380 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53382 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53383 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53384 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53386 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53388 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53389 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53391 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53392 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53393 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53395 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53396 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53397 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53399 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53400 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53402 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53403 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53404 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53405 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53406 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53409 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53411 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53413 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53414 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53415 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53418 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53419 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53420 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53422 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53423 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53424 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53426 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53427 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53428 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53429 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53430 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53431 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53433 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53434 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53435 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53436 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53437 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53438 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53439 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53440 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53446 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53448 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53450 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53451 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53452 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53453 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53454 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53455 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53457 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53458 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53459 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53460 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53461 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53462 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53465 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53466 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53467 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53470 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53471 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53472 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53473 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53474 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53476 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53478 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53481 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53483 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53484 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53486 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53487 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53488 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53490 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53491 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53492 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53494 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53496 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53497 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53498 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53500 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53502 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53504 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53505 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53507 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53508 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53510 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53512 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53513 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53514 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53516 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53518 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53519 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53520 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53522 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53524 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53525 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53526 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53527 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53529 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53531 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53533 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53535 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53536 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53538 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53539 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53540 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53541 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53542 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53543 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53544 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53545 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53547 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53549 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53551 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53553 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53555 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53557 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53558 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53559 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53560 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53561 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53562 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53568 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53569 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53570 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53571 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53572 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53573 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53574 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53576 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53578 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53579 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53581 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53582 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53583 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53584 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53586 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53587 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53588 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53589 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53591 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53592 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53594 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53595 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53596 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53598 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53600 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53601 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53602 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53603 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53604 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53606 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53607 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53608 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53609 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53611 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53612 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53613 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53614 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53615 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53616 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53617 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53618 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53619 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53620 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53622 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53625 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53626 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53627 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53629 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53631 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53633 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53635 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53636 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53646 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53647 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53651 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53652 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53653 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53654 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53655 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53656 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53657 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53658 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53659 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53660 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53661 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53662 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53663 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53664 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53665 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53667 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53668 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53671 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53672 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53677 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53678 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53681 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53682 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53683 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53684 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53687 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53688 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53689 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53691 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53693 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53694 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53695 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53697 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53699 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53701 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53704 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53705 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53706 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53707 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53708 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53709 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53710 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_GetTmpDefaultItem", (PyCFunction)_wrap_Window_GetTmpDefaultItem, METH_O, NULL},
53713 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53717 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53718 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53719 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53720 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53727 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53733 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53734 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53735 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53736 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53737 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53739 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53749 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53750 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53751 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53752 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53755 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53756 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53757 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53758 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53760 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53761 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53765 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53771 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53772 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53773 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53774 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53776 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53777 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53779 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53782 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53784 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53785 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53786 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53795 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53799 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53801 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53812 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53813 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53814 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53815 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53819 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53822 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53824 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53827 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53829 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53830 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53833 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53835 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53836 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53837 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53838 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53839 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53844 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53845 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53846 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53848 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53849 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53850 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53852 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53854 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53855 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53856 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53858 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53859 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53862 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53870 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53877 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53885 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53888 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53889 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53902 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53904 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53906 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53907 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53909 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53911 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53912 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53914 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53915 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53916 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53920 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53939 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53940 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53942 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53944 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53945 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53946 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53948 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53949 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53952 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53953 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53955 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53956 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53958 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53961 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53962 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53964 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53966 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53968 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53969 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53971 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53972 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53975 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53977 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53979 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53981 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53984 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53986 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53987 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53988 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53990 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53991 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53992 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53994 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53997 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53999 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54000 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54004 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54008 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54009 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54011 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54015 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54017 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54019 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54020 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54021 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54022 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54026 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54027 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54028 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54029 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54031 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54032 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54037 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54038 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54039 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54040 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54041 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54043 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54045 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54047 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54048 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54050 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54052 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54055 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54056 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54057 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54059 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54060 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54061 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54075 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54076 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54077 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54078 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54079 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54080 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54086 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54087 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54091 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54092 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54094 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54095 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54097 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54099 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54100 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54102 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54103 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54104 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54110 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54111 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54112 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54113 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54114 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54115 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54122 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54124 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54125 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54126 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54127 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54128 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54129 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54131 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54135 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54136 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54137 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54138 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54139 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54140 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54141 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54143 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54144 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54145 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54151 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54152 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54153 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54155 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54156 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54157 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54163 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54164 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54165 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54166 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54167 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54171 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54172 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54177 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54178 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54180 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54181 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54186 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54188 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54189 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54190 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54191 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54192 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54197 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54198 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54207 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54208 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54209 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54210 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54213 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54215 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54216 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54217 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54218 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54219 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54220 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54225 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54226 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54227 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54228 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54229 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54230 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54231 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54232 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54233 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54234 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54235 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54236 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54237 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54238 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54239 { NULL, NULL, 0, NULL }
54240 };
54241
54242
54243 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54244
54245 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54246 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54247 }
54248 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54249 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54250 }
54251 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54252 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54253 }
54254 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54255 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54256 }
54257 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54258 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54259 }
54260 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54261 return (void *)((wxSizer *) ((wxGridSizer *) x));
54262 }
54263 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54264 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54265 }
54266 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54267 return (void *)((wxSizer *) ((wxPySizer *) x));
54268 }
54269 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54270 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54271 }
54272 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54273 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54274 }
54275 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54276 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54277 }
54278 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54279 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54280 }
54281 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54282 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54283 }
54284 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54285 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54286 }
54287 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54288 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54289 }
54290 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54291 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54292 }
54293 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54294 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54295 }
54296 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54297 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54298 }
54299 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54300 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54301 }
54302 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54303 return (void *)((wxEvent *) ((wxPyEvent *) x));
54304 }
54305 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54306 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54307 }
54308 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54309 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54310 }
54311 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54312 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54313 }
54314 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54315 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54316 }
54317 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54318 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54319 }
54320 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54321 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54322 }
54323 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54324 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54325 }
54326 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54327 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54328 }
54329 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54330 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54331 }
54332 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54333 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54334 }
54335 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54336 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54337 }
54338 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54339 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54340 }
54341 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54342 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54343 }
54344 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54345 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54346 }
54347 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54348 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54349 }
54350 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54351 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54352 }
54353 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54354 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54355 }
54356 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54357 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54358 }
54359 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54360 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54361 }
54362 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54363 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54364 }
54365 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54366 return (void *)((wxEvent *) ((wxShowEvent *) x));
54367 }
54368 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54369 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54370 }
54371 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54372 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54373 }
54374 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54375 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54376 }
54377 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54378 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54379 }
54380 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54381 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54382 }
54383 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54384 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54385 }
54386 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54387 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54388 }
54389 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54390 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54391 }
54392 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54393 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54394 }
54395 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54396 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54397 }
54398 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54399 return (void *)((wxControl *) ((wxControlWithItems *) x));
54400 }
54401 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54402 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54403 }
54404 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54405 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54406 }
54407 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54408 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54409 }
54410 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54411 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54412 }
54413 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54414 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54415 }
54416 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54417 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54418 }
54419 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54420 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54421 }
54422 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54423 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54424 }
54425 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54426 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54427 }
54428 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54429 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54430 }
54431 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54432 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54433 }
54434 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54435 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54436 }
54437 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54438 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54439 }
54440 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54441 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54442 }
54443 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54444 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54445 }
54446 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54447 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54448 }
54449 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54450 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54451 }
54452 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54453 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54454 }
54455 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54456 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54457 }
54458 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54459 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54460 }
54461 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54462 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54463 }
54464 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54465 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54466 }
54467 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54468 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54469 }
54470 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54471 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54472 }
54473 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54474 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54475 }
54476 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54477 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54478 }
54479 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54480 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54481 }
54482 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54483 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54484 }
54485 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54486 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54487 }
54488 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54489 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54490 }
54491 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54492 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54493 }
54494 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54495 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54496 }
54497 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54498 return (void *)((wxObject *) ((wxSizerItem *) x));
54499 }
54500 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54501 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54502 }
54503 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54504 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54505 }
54506 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54507 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54508 }
54509 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54510 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54511 }
54512 static void *_p_wxSizerTo_p_wxObject(void *x) {
54513 return (void *)((wxObject *) ((wxSizer *) x));
54514 }
54515 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54516 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54517 }
54518 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54519 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54520 }
54521 static void *_p_wxEventTo_p_wxObject(void *x) {
54522 return (void *)((wxObject *) ((wxEvent *) x));
54523 }
54524 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54525 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54526 }
54527 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54528 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54529 }
54530 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54531 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54532 }
54533 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54534 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54535 }
54536 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54537 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54538 }
54539 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54540 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54541 }
54542 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54543 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54544 }
54545 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54546 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54547 }
54548 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54549 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54550 }
54551 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54552 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54553 }
54554 static void *_p_wxControlTo_p_wxObject(void *x) {
54555 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54556 }
54557 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54558 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54559 }
54560 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54561 return (void *)((wxObject *) ((wxFSFile *) x));
54562 }
54563 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54564 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54565 }
54566 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54567 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54568 }
54569 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54570 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54571 }
54572 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54573 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54574 }
54575 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54576 return (void *)((wxObject *) ((wxMenuItem *) x));
54577 }
54578 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54579 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54580 }
54581 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54582 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54583 }
54584 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54585 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54586 }
54587 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54588 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54589 }
54590 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54591 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54592 }
54593 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54594 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54595 }
54596 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54597 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54598 }
54599 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54600 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54601 }
54602 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54603 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54604 }
54605 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54606 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54607 }
54608 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54609 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54610 }
54611 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54612 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54613 }
54614 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54615 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54616 }
54617 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54618 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54619 }
54620 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54621 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54622 }
54623 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54624 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54625 }
54626 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54627 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54628 }
54629 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54630 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54631 }
54632 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54633 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54634 }
54635 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54636 return (void *)((wxObject *) ((wxImageHandler *) x));
54637 }
54638 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54639 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54640 }
54641 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54642 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54643 }
54644 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54645 return (void *)((wxObject *) ((wxEvtHandler *) x));
54646 }
54647 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54648 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54649 }
54650 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54651 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54652 }
54653 static void *_p_wxImageTo_p_wxObject(void *x) {
54654 return (void *)((wxObject *) ((wxImage *) x));
54655 }
54656 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54657 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54658 }
54659 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54660 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54661 }
54662 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54663 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54664 }
54665 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54666 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54667 }
54668 static void *_p_wxWindowTo_p_wxObject(void *x) {
54669 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54670 }
54671 static void *_p_wxMenuTo_p_wxObject(void *x) {
54672 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54673 }
54674 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54675 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54676 }
54677 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54678 return (void *)((wxObject *) ((wxFileSystem *) x));
54679 }
54680 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54681 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54682 }
54683 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54684 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54685 }
54686 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54687 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54688 }
54689 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54690 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54691 }
54692 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54693 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54694 }
54695 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54696 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54697 }
54698 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54699 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54700 }
54701 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54702 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54703 }
54704 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54705 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54706 }
54707 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54708 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54709 }
54710 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54711 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54712 }
54713 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54714 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54715 }
54716 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54717 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54718 }
54719 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54720 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54721 }
54722 static void *_p_wxControlTo_p_wxWindow(void *x) {
54723 return (void *)((wxWindow *) ((wxControl *) x));
54724 }
54725 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54726 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54727 }
54728 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54729 return (void *)((wxWindow *) ((wxMenuBar *) x));
54730 }
54731 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54732 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54733 }
54734 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54735 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54736 }
54737 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54738 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54739 }
54740 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54741 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54742 }
54743 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54744 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54745 }
54746 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54747 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54748 }
54749 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54750 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54751 }
54752 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54753 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54754 }
54755 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54756 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54757 }
54758 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54759 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54760 }
54761 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54762 return (void *)((wxValidator *) ((wxPyValidator *) x));
54763 }
54764 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54766 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};
54767 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54777 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54778 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54779 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54780 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54781 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54782 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54783 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54784 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54785 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54786 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54787 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54788 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54789 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54790 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54793 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54895
54896 static swig_type_info *swig_type_initial[] = {
54897 &_swigt__p_buffer,
54898 &_swigt__p_char,
54899 &_swigt__p_form_ops_t,
54900 &_swigt__p_int,
54901 &_swigt__p_long,
54902 &_swigt__p_unsigned_char,
54903 &_swigt__p_unsigned_int,
54904 &_swigt__p_unsigned_long,
54905 &_swigt__p_wxANIHandler,
54906 &_swigt__p_wxAcceleratorEntry,
54907 &_swigt__p_wxAcceleratorTable,
54908 &_swigt__p_wxActivateEvent,
54909 &_swigt__p_wxAppTraits,
54910 &_swigt__p_wxArrayString,
54911 &_swigt__p_wxBMPHandler,
54912 &_swigt__p_wxBitmap,
54913 &_swigt__p_wxBoxSizer,
54914 &_swigt__p_wxButton,
54915 &_swigt__p_wxCURHandler,
54916 &_swigt__p_wxCaret,
54917 &_swigt__p_wxChildFocusEvent,
54918 &_swigt__p_wxClipboardTextEvent,
54919 &_swigt__p_wxCloseEvent,
54920 &_swigt__p_wxColour,
54921 &_swigt__p_wxCommandEvent,
54922 &_swigt__p_wxContextMenuEvent,
54923 &_swigt__p_wxControl,
54924 &_swigt__p_wxControlWithItems,
54925 &_swigt__p_wxCursor,
54926 &_swigt__p_wxDC,
54927 &_swigt__p_wxDateEvent,
54928 &_swigt__p_wxDateTime,
54929 &_swigt__p_wxDisplayChangedEvent,
54930 &_swigt__p_wxDropFilesEvent,
54931 &_swigt__p_wxDuplexMode,
54932 &_swigt__p_wxEraseEvent,
54933 &_swigt__p_wxEvent,
54934 &_swigt__p_wxEventLoop,
54935 &_swigt__p_wxEventLoopActivator,
54936 &_swigt__p_wxEvtHandler,
54937 &_swigt__p_wxFSFile,
54938 &_swigt__p_wxFileSystem,
54939 &_swigt__p_wxFileSystemHandler,
54940 &_swigt__p_wxFlexGridSizer,
54941 &_swigt__p_wxFocusEvent,
54942 &_swigt__p_wxFont,
54943 &_swigt__p_wxFrame,
54944 &_swigt__p_wxGBPosition,
54945 &_swigt__p_wxGBSizerItem,
54946 &_swigt__p_wxGBSpan,
54947 &_swigt__p_wxGIFHandler,
54948 &_swigt__p_wxGridBagSizer,
54949 &_swigt__p_wxGridSizer,
54950 &_swigt__p_wxHelpEvent__Origin,
54951 &_swigt__p_wxICOHandler,
54952 &_swigt__p_wxIconizeEvent,
54953 &_swigt__p_wxIdleEvent,
54954 &_swigt__p_wxImage,
54955 &_swigt__p_wxImageHandler,
54956 &_swigt__p_wxImageHistogram,
54957 &_swigt__p_wxImage_HSVValue,
54958 &_swigt__p_wxImage_RGBValue,
54959 &_swigt__p_wxIndividualLayoutConstraint,
54960 &_swigt__p_wxInitDialogEvent,
54961 &_swigt__p_wxInputStream,
54962 &_swigt__p_wxInternetFSHandler,
54963 &_swigt__p_wxItemContainer,
54964 &_swigt__p_wxJPEGHandler,
54965 &_swigt__p_wxKeyEvent,
54966 &_swigt__p_wxLayoutConstraints,
54967 &_swigt__p_wxMaximizeEvent,
54968 &_swigt__p_wxMemoryFSHandler,
54969 &_swigt__p_wxMenu,
54970 &_swigt__p_wxMenuBar,
54971 &_swigt__p_wxMenuBarBase,
54972 &_swigt__p_wxMenuEvent,
54973 &_swigt__p_wxMenuItem,
54974 &_swigt__p_wxMouseCaptureChangedEvent,
54975 &_swigt__p_wxMouseEvent,
54976 &_swigt__p_wxMoveEvent,
54977 &_swigt__p_wxNavigationKeyEvent,
54978 &_swigt__p_wxNcPaintEvent,
54979 &_swigt__p_wxNotifyEvent,
54980 &_swigt__p_wxObject,
54981 &_swigt__p_wxOutputStream,
54982 &_swigt__p_wxPCXHandler,
54983 &_swigt__p_wxPNGHandler,
54984 &_swigt__p_wxPNMHandler,
54985 &_swigt__p_wxPaintEvent,
54986 &_swigt__p_wxPaletteChangedEvent,
54987 &_swigt__p_wxPaperSize,
54988 &_swigt__p_wxPoint,
54989 &_swigt__p_wxPoint2D,
54990 &_swigt__p_wxPropagateOnce,
54991 &_swigt__p_wxPropagationDisabler,
54992 &_swigt__p_wxPyApp,
54993 &_swigt__p_wxPyCommandEvent,
54994 &_swigt__p_wxPyDropTarget,
54995 &_swigt__p_wxPyEvent,
54996 &_swigt__p_wxPyFileSystemHandler,
54997 &_swigt__p_wxPyImageHandler,
54998 &_swigt__p_wxPyInputStream,
54999 &_swigt__p_wxPySizer,
55000 &_swigt__p_wxPyValidator,
55001 &_swigt__p_wxQuantize,
55002 &_swigt__p_wxQueryNewPaletteEvent,
55003 &_swigt__p_wxRealPoint,
55004 &_swigt__p_wxRect,
55005 &_swigt__p_wxRegion,
55006 &_swigt__p_wxScrollEvent,
55007 &_swigt__p_wxScrollWinEvent,
55008 &_swigt__p_wxSetCursorEvent,
55009 &_swigt__p_wxShowEvent,
55010 &_swigt__p_wxSize,
55011 &_swigt__p_wxSizeEvent,
55012 &_swigt__p_wxSizer,
55013 &_swigt__p_wxSizerItem,
55014 &_swigt__p_wxStaticBox,
55015 &_swigt__p_wxStaticBoxSizer,
55016 &_swigt__p_wxStdDialogButtonSizer,
55017 &_swigt__p_wxSysColourChangedEvent,
55018 &_swigt__p_wxTIFFHandler,
55019 &_swigt__p_wxToolTip,
55020 &_swigt__p_wxUpdateUIEvent,
55021 &_swigt__p_wxValidator,
55022 &_swigt__p_wxVisualAttributes,
55023 &_swigt__p_wxWindow,
55024 &_swigt__p_wxWindowCreateEvent,
55025 &_swigt__p_wxWindowDestroyEvent,
55026 &_swigt__p_wxXPMHandler,
55027 &_swigt__p_wxZipFSHandler,
55028 };
55029
55030 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55031 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55032 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55034 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55035 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55036 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55037 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55038 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55039 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55042 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55043 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55044 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}};
55045 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55046 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}};
55047 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55048 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}};
55049 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55050 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55051 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55052 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55053 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55054 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}};
55055 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55056 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}};
55057 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55058 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55061 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55062 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55065 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55066 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_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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}};
55067 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55072 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}};
55073 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}};
55074 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55082 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}};
55083 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55084 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}};
55085 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55086 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55095 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55096 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}};
55097 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55101 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55102 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55103 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55104 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55109 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55110 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55111 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55112 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55113 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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_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_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_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}};
55114 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55120 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55121 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55122 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55123 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55124 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55125 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55126 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55127 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55128 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55129 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55130 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55131 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55134 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55135 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55136 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55137 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55138 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55139 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55140 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55141 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55142 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55143 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55144 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55145 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}};
55146 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}};
55147 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55148 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55149 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55150 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55151 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55152 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55153 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55154 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}};
55155 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55156 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}};
55157 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55161
55162 static swig_cast_info *swig_cast_initial[] = {
55163 _swigc__p_buffer,
55164 _swigc__p_char,
55165 _swigc__p_form_ops_t,
55166 _swigc__p_int,
55167 _swigc__p_long,
55168 _swigc__p_unsigned_char,
55169 _swigc__p_unsigned_int,
55170 _swigc__p_unsigned_long,
55171 _swigc__p_wxANIHandler,
55172 _swigc__p_wxAcceleratorEntry,
55173 _swigc__p_wxAcceleratorTable,
55174 _swigc__p_wxActivateEvent,
55175 _swigc__p_wxAppTraits,
55176 _swigc__p_wxArrayString,
55177 _swigc__p_wxBMPHandler,
55178 _swigc__p_wxBitmap,
55179 _swigc__p_wxBoxSizer,
55180 _swigc__p_wxButton,
55181 _swigc__p_wxCURHandler,
55182 _swigc__p_wxCaret,
55183 _swigc__p_wxChildFocusEvent,
55184 _swigc__p_wxClipboardTextEvent,
55185 _swigc__p_wxCloseEvent,
55186 _swigc__p_wxColour,
55187 _swigc__p_wxCommandEvent,
55188 _swigc__p_wxContextMenuEvent,
55189 _swigc__p_wxControl,
55190 _swigc__p_wxControlWithItems,
55191 _swigc__p_wxCursor,
55192 _swigc__p_wxDC,
55193 _swigc__p_wxDateEvent,
55194 _swigc__p_wxDateTime,
55195 _swigc__p_wxDisplayChangedEvent,
55196 _swigc__p_wxDropFilesEvent,
55197 _swigc__p_wxDuplexMode,
55198 _swigc__p_wxEraseEvent,
55199 _swigc__p_wxEvent,
55200 _swigc__p_wxEventLoop,
55201 _swigc__p_wxEventLoopActivator,
55202 _swigc__p_wxEvtHandler,
55203 _swigc__p_wxFSFile,
55204 _swigc__p_wxFileSystem,
55205 _swigc__p_wxFileSystemHandler,
55206 _swigc__p_wxFlexGridSizer,
55207 _swigc__p_wxFocusEvent,
55208 _swigc__p_wxFont,
55209 _swigc__p_wxFrame,
55210 _swigc__p_wxGBPosition,
55211 _swigc__p_wxGBSizerItem,
55212 _swigc__p_wxGBSpan,
55213 _swigc__p_wxGIFHandler,
55214 _swigc__p_wxGridBagSizer,
55215 _swigc__p_wxGridSizer,
55216 _swigc__p_wxHelpEvent__Origin,
55217 _swigc__p_wxICOHandler,
55218 _swigc__p_wxIconizeEvent,
55219 _swigc__p_wxIdleEvent,
55220 _swigc__p_wxImage,
55221 _swigc__p_wxImageHandler,
55222 _swigc__p_wxImageHistogram,
55223 _swigc__p_wxImage_HSVValue,
55224 _swigc__p_wxImage_RGBValue,
55225 _swigc__p_wxIndividualLayoutConstraint,
55226 _swigc__p_wxInitDialogEvent,
55227 _swigc__p_wxInputStream,
55228 _swigc__p_wxInternetFSHandler,
55229 _swigc__p_wxItemContainer,
55230 _swigc__p_wxJPEGHandler,
55231 _swigc__p_wxKeyEvent,
55232 _swigc__p_wxLayoutConstraints,
55233 _swigc__p_wxMaximizeEvent,
55234 _swigc__p_wxMemoryFSHandler,
55235 _swigc__p_wxMenu,
55236 _swigc__p_wxMenuBar,
55237 _swigc__p_wxMenuBarBase,
55238 _swigc__p_wxMenuEvent,
55239 _swigc__p_wxMenuItem,
55240 _swigc__p_wxMouseCaptureChangedEvent,
55241 _swigc__p_wxMouseEvent,
55242 _swigc__p_wxMoveEvent,
55243 _swigc__p_wxNavigationKeyEvent,
55244 _swigc__p_wxNcPaintEvent,
55245 _swigc__p_wxNotifyEvent,
55246 _swigc__p_wxObject,
55247 _swigc__p_wxOutputStream,
55248 _swigc__p_wxPCXHandler,
55249 _swigc__p_wxPNGHandler,
55250 _swigc__p_wxPNMHandler,
55251 _swigc__p_wxPaintEvent,
55252 _swigc__p_wxPaletteChangedEvent,
55253 _swigc__p_wxPaperSize,
55254 _swigc__p_wxPoint,
55255 _swigc__p_wxPoint2D,
55256 _swigc__p_wxPropagateOnce,
55257 _swigc__p_wxPropagationDisabler,
55258 _swigc__p_wxPyApp,
55259 _swigc__p_wxPyCommandEvent,
55260 _swigc__p_wxPyDropTarget,
55261 _swigc__p_wxPyEvent,
55262 _swigc__p_wxPyFileSystemHandler,
55263 _swigc__p_wxPyImageHandler,
55264 _swigc__p_wxPyInputStream,
55265 _swigc__p_wxPySizer,
55266 _swigc__p_wxPyValidator,
55267 _swigc__p_wxQuantize,
55268 _swigc__p_wxQueryNewPaletteEvent,
55269 _swigc__p_wxRealPoint,
55270 _swigc__p_wxRect,
55271 _swigc__p_wxRegion,
55272 _swigc__p_wxScrollEvent,
55273 _swigc__p_wxScrollWinEvent,
55274 _swigc__p_wxSetCursorEvent,
55275 _swigc__p_wxShowEvent,
55276 _swigc__p_wxSize,
55277 _swigc__p_wxSizeEvent,
55278 _swigc__p_wxSizer,
55279 _swigc__p_wxSizerItem,
55280 _swigc__p_wxStaticBox,
55281 _swigc__p_wxStaticBoxSizer,
55282 _swigc__p_wxStdDialogButtonSizer,
55283 _swigc__p_wxSysColourChangedEvent,
55284 _swigc__p_wxTIFFHandler,
55285 _swigc__p_wxToolTip,
55286 _swigc__p_wxUpdateUIEvent,
55287 _swigc__p_wxValidator,
55288 _swigc__p_wxVisualAttributes,
55289 _swigc__p_wxWindow,
55290 _swigc__p_wxWindowCreateEvent,
55291 _swigc__p_wxWindowDestroyEvent,
55292 _swigc__p_wxXPMHandler,
55293 _swigc__p_wxZipFSHandler,
55294 };
55295
55296
55297 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55298
55299 static swig_const_info swig_const_table[] = {
55300 {0, 0, 0, 0.0, 0, 0}};
55301
55302 #ifdef __cplusplus
55303 }
55304 #endif
55305 /* -----------------------------------------------------------------------------
55306 * Type initialization:
55307 * This problem is tough by the requirement that no dynamic
55308 * memory is used. Also, since swig_type_info structures store pointers to
55309 * swig_cast_info structures and swig_cast_info structures store pointers back
55310 * to swig_type_info structures, we need some lookup code at initialization.
55311 * The idea is that swig generates all the structures that are needed.
55312 * The runtime then collects these partially filled structures.
55313 * The SWIG_InitializeModule function takes these initial arrays out of
55314 * swig_module, and does all the lookup, filling in the swig_module.types
55315 * array with the correct data and linking the correct swig_cast_info
55316 * structures together.
55317 *
55318 * The generated swig_type_info structures are assigned staticly to an initial
55319 * array. We just loop though that array, and handle each type individually.
55320 * First we lookup if this type has been already loaded, and if so, use the
55321 * loaded structure instead of the generated one. Then we have to fill in the
55322 * cast linked list. The cast data is initially stored in something like a
55323 * two-dimensional array. Each row corresponds to a type (there are the same
55324 * number of rows as there are in the swig_type_initial array). Each entry in
55325 * a column is one of the swig_cast_info structures for that type.
55326 * The cast_initial array is actually an array of arrays, because each row has
55327 * a variable number of columns. So to actually build the cast linked list,
55328 * we find the array of casts associated with the type, and loop through it
55329 * adding the casts to the list. The one last trick we need to do is making
55330 * sure the type pointer in the swig_cast_info struct is correct.
55331 *
55332 * First off, we lookup the cast->type name to see if it is already loaded.
55333 * There are three cases to handle:
55334 * 1) If the cast->type has already been loaded AND the type we are adding
55335 * casting info to has not been loaded (it is in this module), THEN we
55336 * replace the cast->type pointer with the type pointer that has already
55337 * been loaded.
55338 * 2) If BOTH types (the one we are adding casting info to, and the
55339 * cast->type) are loaded, THEN the cast info has already been loaded by
55340 * the previous module so we just ignore it.
55341 * 3) Finally, if cast->type has not already been loaded, then we add that
55342 * swig_cast_info to the linked list (because the cast->type) pointer will
55343 * be correct.
55344 * ----------------------------------------------------------------------------- */
55345
55346 #ifdef __cplusplus
55347 extern "C" {
55348 #if 0
55349 } /* c-mode */
55350 #endif
55351 #endif
55352
55353 #if 0
55354 #define SWIGRUNTIME_DEBUG
55355 #endif
55356
55357 SWIGRUNTIME void
55358 SWIG_InitializeModule(void *clientdata) {
55359 size_t i;
55360 swig_module_info *module_head;
55361 static int init_run = 0;
55362
55363 clientdata = clientdata;
55364
55365 if (init_run) return;
55366 init_run = 1;
55367
55368 /* Initialize the swig_module */
55369 swig_module.type_initial = swig_type_initial;
55370 swig_module.cast_initial = swig_cast_initial;
55371
55372 /* Try and load any already created modules */
55373 module_head = SWIG_GetModule(clientdata);
55374 if (module_head) {
55375 swig_module.next = module_head->next;
55376 module_head->next = &swig_module;
55377 } else {
55378 /* This is the first module loaded */
55379 swig_module.next = &swig_module;
55380 SWIG_SetModule(clientdata, &swig_module);
55381 }
55382
55383 /* Now work on filling in swig_module.types */
55384 #ifdef SWIGRUNTIME_DEBUG
55385 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55386 #endif
55387 for (i = 0; i < swig_module.size; ++i) {
55388 swig_type_info *type = 0;
55389 swig_type_info *ret;
55390 swig_cast_info *cast;
55391
55392 #ifdef SWIGRUNTIME_DEBUG
55393 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55394 #endif
55395
55396 /* if there is another module already loaded */
55397 if (swig_module.next != &swig_module) {
55398 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55399 }
55400 if (type) {
55401 /* Overwrite clientdata field */
55402 #ifdef SWIGRUNTIME_DEBUG
55403 printf("SWIG_InitializeModule: found type %s\n", type->name);
55404 #endif
55405 if (swig_module.type_initial[i]->clientdata) {
55406 type->clientdata = swig_module.type_initial[i]->clientdata;
55407 #ifdef SWIGRUNTIME_DEBUG
55408 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55409 #endif
55410 }
55411 } else {
55412 type = swig_module.type_initial[i];
55413 }
55414
55415 /* Insert casting types */
55416 cast = swig_module.cast_initial[i];
55417 while (cast->type) {
55418 /* Don't need to add information already in the list */
55419 ret = 0;
55420 #ifdef SWIGRUNTIME_DEBUG
55421 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55422 #endif
55423 if (swig_module.next != &swig_module) {
55424 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55425 #ifdef SWIGRUNTIME_DEBUG
55426 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55427 #endif
55428 }
55429 if (ret) {
55430 if (type == swig_module.type_initial[i]) {
55431 #ifdef SWIGRUNTIME_DEBUG
55432 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55433 #endif
55434 cast->type = ret;
55435 ret = 0;
55436 } else {
55437 /* Check for casting already in the list */
55438 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55439 #ifdef SWIGRUNTIME_DEBUG
55440 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55441 #endif
55442 if (!ocast) ret = 0;
55443 }
55444 }
55445
55446 if (!ret) {
55447 #ifdef SWIGRUNTIME_DEBUG
55448 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55449 #endif
55450 if (type->cast) {
55451 type->cast->prev = cast;
55452 cast->next = type->cast;
55453 }
55454 type->cast = cast;
55455 }
55456 cast++;
55457 }
55458 /* Set entry in modules->types array equal to the type */
55459 swig_module.types[i] = type;
55460 }
55461 swig_module.types[i] = 0;
55462
55463 #ifdef SWIGRUNTIME_DEBUG
55464 printf("**** SWIG_InitializeModule: Cast List ******\n");
55465 for (i = 0; i < swig_module.size; ++i) {
55466 int j = 0;
55467 swig_cast_info *cast = swig_module.cast_initial[i];
55468 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55469 while (cast->type) {
55470 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55471 cast++;
55472 ++j;
55473 }
55474 printf("---- Total casts: %d\n",j);
55475 }
55476 printf("**** SWIG_InitializeModule: Cast List ******\n");
55477 #endif
55478 }
55479
55480 /* This function will propagate the clientdata field of type to
55481 * any new swig_type_info structures that have been added into the list
55482 * of equivalent types. It is like calling
55483 * SWIG_TypeClientData(type, clientdata) a second time.
55484 */
55485 SWIGRUNTIME void
55486 SWIG_PropagateClientData(void) {
55487 size_t i;
55488 swig_cast_info *equiv;
55489 static int init_run = 0;
55490
55491 if (init_run) return;
55492 init_run = 1;
55493
55494 for (i = 0; i < swig_module.size; i++) {
55495 if (swig_module.types[i]->clientdata) {
55496 equiv = swig_module.types[i]->cast;
55497 while (equiv) {
55498 if (!equiv->converter) {
55499 if (equiv->type && !equiv->type->clientdata)
55500 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55501 }
55502 equiv = equiv->next;
55503 }
55504 }
55505 }
55506 }
55507
55508 #ifdef __cplusplus
55509 #if 0
55510 {
55511 /* c-mode */
55512 #endif
55513 }
55514 #endif
55515
55516
55517
55518 #ifdef __cplusplus
55519 extern "C" {
55520 #endif
55521
55522 /* Python-specific SWIG API */
55523 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55524 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55525 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55526
55527 /* -----------------------------------------------------------------------------
55528 * global variable support code.
55529 * ----------------------------------------------------------------------------- */
55530
55531 typedef struct swig_globalvar {
55532 char *name; /* Name of global variable */
55533 PyObject *(*get_attr)(void); /* Return the current value */
55534 int (*set_attr)(PyObject *); /* Set the value */
55535 struct swig_globalvar *next;
55536 } swig_globalvar;
55537
55538 typedef struct swig_varlinkobject {
55539 PyObject_HEAD
55540 swig_globalvar *vars;
55541 } swig_varlinkobject;
55542
55543 SWIGINTERN PyObject *
55544 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55545 return PyString_FromString("<Swig global variables>");
55546 }
55547
55548 SWIGINTERN PyObject *
55549 swig_varlink_str(swig_varlinkobject *v) {
55550 PyObject *str = PyString_FromString("(");
55551 swig_globalvar *var;
55552 for (var = v->vars; var; var=var->next) {
55553 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55554 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55555 }
55556 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55557 return str;
55558 }
55559
55560 SWIGINTERN int
55561 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55562 PyObject *str = swig_varlink_str(v);
55563 fprintf(fp,"Swig global variables ");
55564 fprintf(fp,"%s\n", PyString_AsString(str));
55565 Py_DECREF(str);
55566 return 0;
55567 }
55568
55569 SWIGINTERN void
55570 swig_varlink_dealloc(swig_varlinkobject *v) {
55571 swig_globalvar *var = v->vars;
55572 while (var) {
55573 swig_globalvar *n = var->next;
55574 free(var->name);
55575 free(var);
55576 var = n;
55577 }
55578 }
55579
55580 SWIGINTERN PyObject *
55581 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55582 PyObject *res = NULL;
55583 swig_globalvar *var = v->vars;
55584 while (var) {
55585 if (strcmp(var->name,n) == 0) {
55586 res = (*var->get_attr)();
55587 break;
55588 }
55589 var = var->next;
55590 }
55591 if (res == NULL && !PyErr_Occurred()) {
55592 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55593 }
55594 return res;
55595 }
55596
55597 SWIGINTERN int
55598 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55599 int res = 1;
55600 swig_globalvar *var = v->vars;
55601 while (var) {
55602 if (strcmp(var->name,n) == 0) {
55603 res = (*var->set_attr)(p);
55604 break;
55605 }
55606 var = var->next;
55607 }
55608 if (res == 1 && !PyErr_Occurred()) {
55609 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55610 }
55611 return res;
55612 }
55613
55614 SWIGINTERN PyTypeObject*
55615 swig_varlink_type(void) {
55616 static char varlink__doc__[] = "Swig var link object";
55617 static PyTypeObject varlink_type;
55618 static int type_init = 0;
55619 if (!type_init) {
55620 const PyTypeObject tmp
55621 = {
55622 PyObject_HEAD_INIT(NULL)
55623 0, /* Number of items in variable part (ob_size) */
55624 (char *)"swigvarlink", /* Type name (tp_name) */
55625 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55626 0, /* Itemsize (tp_itemsize) */
55627 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55628 (printfunc) swig_varlink_print, /* Print (tp_print) */
55629 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55630 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55631 0, /* tp_compare */
55632 (reprfunc) swig_varlink_repr, /* tp_repr */
55633 0, /* tp_as_number */
55634 0, /* tp_as_sequence */
55635 0, /* tp_as_mapping */
55636 0, /* tp_hash */
55637 0, /* tp_call */
55638 (reprfunc)swig_varlink_str, /* tp_str */
55639 0, /* tp_getattro */
55640 0, /* tp_setattro */
55641 0, /* tp_as_buffer */
55642 0, /* tp_flags */
55643 varlink__doc__, /* tp_doc */
55644 0, /* tp_traverse */
55645 0, /* tp_clear */
55646 0, /* tp_richcompare */
55647 0, /* tp_weaklistoffset */
55648 #if PY_VERSION_HEX >= 0x02020000
55649 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55650 #endif
55651 #if PY_VERSION_HEX >= 0x02030000
55652 0, /* tp_del */
55653 #endif
55654 #ifdef COUNT_ALLOCS
55655 0,0,0,0 /* tp_alloc -> tp_next */
55656 #endif
55657 };
55658 varlink_type = tmp;
55659 varlink_type.ob_type = &PyType_Type;
55660 type_init = 1;
55661 }
55662 return &varlink_type;
55663 }
55664
55665 /* Create a variable linking object for use later */
55666 SWIGINTERN PyObject *
55667 SWIG_Python_newvarlink(void) {
55668 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55669 if (result) {
55670 result->vars = 0;
55671 }
55672 return ((PyObject*) result);
55673 }
55674
55675 SWIGINTERN void
55676 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55677 swig_varlinkobject *v = (swig_varlinkobject *) p;
55678 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55679 if (gv) {
55680 size_t size = strlen(name)+1;
55681 gv->name = (char *)malloc(size);
55682 if (gv->name) {
55683 strncpy(gv->name,name,size);
55684 gv->get_attr = get_attr;
55685 gv->set_attr = set_attr;
55686 gv->next = v->vars;
55687 }
55688 }
55689 v->vars = gv;
55690 }
55691
55692 SWIGINTERN PyObject *
55693 SWIG_globals() {
55694 static PyObject *_SWIG_globals = 0;
55695 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55696 return _SWIG_globals;
55697 }
55698
55699 /* -----------------------------------------------------------------------------
55700 * constants/methods manipulation
55701 * ----------------------------------------------------------------------------- */
55702
55703 /* Install Constants */
55704 SWIGINTERN void
55705 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55706 PyObject *obj = 0;
55707 size_t i;
55708 for (i = 0; constants[i].type; ++i) {
55709 switch(constants[i].type) {
55710 case SWIG_PY_POINTER:
55711 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55712 break;
55713 case SWIG_PY_BINARY:
55714 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55715 break;
55716 default:
55717 obj = 0;
55718 break;
55719 }
55720 if (obj) {
55721 PyDict_SetItemString(d, constants[i].name, obj);
55722 Py_DECREF(obj);
55723 }
55724 }
55725 }
55726
55727 /* -----------------------------------------------------------------------------*/
55728 /* Fix SwigMethods to carry the callback ptrs when needed */
55729 /* -----------------------------------------------------------------------------*/
55730
55731 SWIGINTERN void
55732 SWIG_Python_FixMethods(PyMethodDef *methods,
55733 swig_const_info *const_table,
55734 swig_type_info **types,
55735 swig_type_info **types_initial) {
55736 size_t i;
55737 for (i = 0; methods[i].ml_name; ++i) {
55738 const char *c = methods[i].ml_doc;
55739 if (c && (c = strstr(c, "swig_ptr: "))) {
55740 int j;
55741 swig_const_info *ci = 0;
55742 const char *name = c + 10;
55743 for (j = 0; const_table[j].type; ++j) {
55744 if (strncmp(const_table[j].name, name,
55745 strlen(const_table[j].name)) == 0) {
55746 ci = &(const_table[j]);
55747 break;
55748 }
55749 }
55750 if (ci) {
55751 size_t shift = (ci->ptype) - types;
55752 swig_type_info *ty = types_initial[shift];
55753 size_t ldoc = (c - methods[i].ml_doc);
55754 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55755 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55756 if (ndoc) {
55757 char *buff = ndoc;
55758 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55759 if (ptr) {
55760 strncpy(buff, methods[i].ml_doc, ldoc);
55761 buff += ldoc;
55762 strncpy(buff, "swig_ptr: ", 10);
55763 buff += 10;
55764 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55765 methods[i].ml_doc = ndoc;
55766 }
55767 }
55768 }
55769 }
55770 }
55771 }
55772
55773 #ifdef __cplusplus
55774 }
55775 #endif
55776
55777 /* -----------------------------------------------------------------------------*
55778 * Partial Init method
55779 * -----------------------------------------------------------------------------*/
55780
55781 #ifdef __cplusplus
55782 extern "C"
55783 #endif
55784 SWIGEXPORT void SWIG_init(void) {
55785 PyObject *m, *d;
55786
55787 /* Fix SwigMethods to carry the callback ptrs when needed */
55788 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55789
55790 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55791 d = PyModule_GetDict(m);
55792
55793 SWIG_InitializeModule(0);
55794 SWIG_InstallConstants(d,swig_const_table);
55795
55796
55797
55798 #ifndef wxPyUSE_EXPORT
55799 // Make our API structure a CObject so other modules can import it
55800 // from this module.
55801 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55802 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55803 Py_XDECREF(cobj);
55804 #endif
55805
55806 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55807 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55808 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55809 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55810 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55811 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55812 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55813 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55814 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55815 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55816 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55817 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55818 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55819 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55820 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55821 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55822 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55823 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55824 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55825 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55826 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55827 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55828 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55829 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55830 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55831 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55832 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55833 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55834 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55835 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55836 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55837 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55838 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55839 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55840 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55841 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55842 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55843 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55844 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55845 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55846 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55847 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55848 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55849 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55850 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55851 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55852 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55853 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55854 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55855 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55856 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55857 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55858 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55859 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55860 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55861 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55862 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55863 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55864 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55865 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55866 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55867 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55868 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55869 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55870 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55871 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55872 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55873 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55874 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55875 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55876 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55877 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55878 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55879 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55880 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55881 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55882 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55883 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55884 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55885 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55886 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55887 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55888 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55889 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55890 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55891 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55892 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55893 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55894 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55895 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55896 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55897 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55898 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55899 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55900 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55901 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55902 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55903 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55904 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55905 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55906 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55907 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55908 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55909 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55910 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55911 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55912 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55913 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55914 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55915 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55916 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55917 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55918 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55919 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55920 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55921 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55922 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55923 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55924 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55925 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55926 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55927 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55928 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55929 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55930 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55931 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55932 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55933 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55934 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55935 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55936 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55937 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55938 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55939 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55940 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55941 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55942 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55943 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55944 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55945 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55946 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55947 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55948 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55949 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55950 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55951 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55952 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55953 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55954 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55955 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55956 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55957 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55958 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55959 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55960 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55961 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55962 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55963 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55964 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55965 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55966 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55967 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55968 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55969 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55970 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55971 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55972 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55973 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55974 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55975 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55976 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55977 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55978 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55979 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55980 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55981 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55982 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55983 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55984 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55985 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55986 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55987 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55988 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55989 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55990 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55991 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55992 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55993 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55994 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55995 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55996 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55997 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55998 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55999 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56000 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56001 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56002 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56003 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56004 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56005 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56006 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56007 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56008 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56009 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56010 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56011 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56012 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56013 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56014 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56015 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56016 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56017 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56018 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56019 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56020 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56021 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56022 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56023 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56024 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56025 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56026 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56027 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56028 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56029 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56030 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56031 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56032 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56033 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56034 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56035 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56036 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56037 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56038 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56039 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56040 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56041 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56042 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56043 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56044 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56045 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56046 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56047 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56048 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56049 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56050 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56051 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56052 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56053 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56054 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56055 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56056 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56057 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56058 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56059 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56060 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56061 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56062 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56063 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56064 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56065 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56066 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56067 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56068 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56069 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56070 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56071 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56072 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56073 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56074 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56075 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56076 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56077 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56078 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56079 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56080 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56081 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56082 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56083 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56084 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56085 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56086 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56087 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56088 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56089 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56090 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56091 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56092 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56093 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56094 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56095 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56096 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56097 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56098 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56099 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56100 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56101 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56102 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56103 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56104 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56105 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56106 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56107 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56108 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56109 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56110 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56111 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56112 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56113 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56114 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56115 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56116 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56117 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56118 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56119 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56120 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56121 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56122 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56123 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56124 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56125 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56126 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56127 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56128 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56129 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56130 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56131 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56132 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56133 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56134 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56135 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56136 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56137 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56138 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56139 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56140 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56141 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56142 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56143 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56144 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56145 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56146 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56147 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56148 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56149 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56150 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56151 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56152 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56153 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56154 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56155 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56156 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56157 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56158 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56159 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56160 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56161 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56162 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56163 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56164 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56165 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56166 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56167 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56168 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56169 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56170 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56171 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56172 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56173 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56174 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56175 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56176 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56177 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56178 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56179 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56180 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56181 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56182 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56183 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56184 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56185 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56186 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56187 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56188 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56189 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56190 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56191 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56192 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56193 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56194 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56195 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56196 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56197 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56198 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56199 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56200 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56201 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56202 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56203 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56204 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56205 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56206 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56207 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56208 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56209 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56210 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56211 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56212 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56213 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56214 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56215 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56216 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56217 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56218 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56219 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56220 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56221 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56222 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56223 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56224 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56225 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56226 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56227 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56228 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56229 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56230 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56231 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56232 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56233 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56234 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56235 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56236 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56237 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56238 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56239 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56240 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56241 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56242 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56243 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56244 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56245 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56246 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56247 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56248 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56249 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56250 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56251 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56252 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56253 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56254 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56255 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56256 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56257 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56258 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56259 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56260 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56261 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56262 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56263 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56264 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56265 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56266 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56267 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56268 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56269 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56270 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56271 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56272 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56273 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56274 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56275 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56276 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56277 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56278 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56279 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56280 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56281 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56282 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56283 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56284 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56285 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56286 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56287 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56288 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56289 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56290 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56291 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56292 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56293 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56294 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56295 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56296 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56297 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56298 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56299 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56300 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56301 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56302 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56303 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56304 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56305 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56306 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56307 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56308 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56309 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56310 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56311 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56312 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56313 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56314 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56315 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56316 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56317 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56318 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56319 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56320 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56321 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56322 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56323 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56324 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56325 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56326 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56327 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56328 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56329 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56330 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56331 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56332 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56333 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56334 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56335 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56336 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56337 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56338 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56339 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56340 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56341 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56342 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56343 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56344 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56345 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56346 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56347 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56348 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56349 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56350 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56351 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56352 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56353 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56354 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56355 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56356 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56357 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56358 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56359 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56360 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56361 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56362 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56363 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56364 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56365 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56366 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56367 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56368 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56369 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56370 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56371 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56372 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56373 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56374 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56375 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56376 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56377 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56378 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56379 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56380 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56381 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56382 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56383 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56384 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56385 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56386 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56387 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56388 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56389 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56390 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56391 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56392 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56393 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56394 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56395 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56396 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56397 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56398 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56399 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56400 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56401 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56402 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56403 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56404 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56405 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56406 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56407 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56408 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56409 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56410 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56411 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56412 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56413 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56414 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56415 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56416 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56417 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56418 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56419 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56420 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56421 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56422 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56423 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56424 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56425 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56426 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56427 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56428 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56429 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56430 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56431 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56432 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56433 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56434 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56435 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56436 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56437 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56438 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56439 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56440 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56441 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56442 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56443 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56444 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56445 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56446 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56447 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56448 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56449 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56450 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56451 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56452 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56453 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56454 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56455 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56456 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56457 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56458 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56459 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56460 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56461 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56462 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56463 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56464 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56465 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56466 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56467 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56468 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56469
56470 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56471
56472
56473 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56474
56475 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56476 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56477 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56478 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56479 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56480 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56481 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56482 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56483 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56484 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56485 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56486 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56487 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56488 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56489 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56490 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56491 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56492 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56493 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56494 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56495 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56496 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56497 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56498 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56499 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56500 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56501 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56502 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56503 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56504 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56505 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56506 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56507 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56508 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56509 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56510 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56511 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56512 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56513 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56514 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56515 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56516 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56517 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56518 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56519 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56520 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56521 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56522 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56523 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56524 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56525 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56526 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56527 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56528 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56529 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56530 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56531 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56532 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56533 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56534 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56535 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56536 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56537 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56538 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56539 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56540 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56541 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56542 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56543 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56544 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56545 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56546 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56547 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56548 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56549 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56550 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56551 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56552 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56553 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56554 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56555 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56556 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56557 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56558 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56559 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56560 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56561 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56562 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56563 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56564 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56565 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56566 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56567 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56568 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56569 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56570 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56571 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56572 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56573 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56574 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56575 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56576 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56577 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56578 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56579 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56580 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56581 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56582 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56583 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56584 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56585 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56586 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56587 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56588 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56589 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56590 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56591 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56592 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56593 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56594 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56595 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56596 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56597 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56598 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56599 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56600 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56601 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56602 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56603 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56604 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56605 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56606 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56607 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56608 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56609 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56610 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56611 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56612 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56613 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56614 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56615 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56616 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56617 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56618 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56619 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56620 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56621 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56622 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56623 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56624 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56625 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56626 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56627 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56628 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56629 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56630 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56631 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56632 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56633 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56634 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56635 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56636 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56637 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56638 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56639 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56640 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56641 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56642 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56643 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56644 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56645 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56646 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56647 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56648 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56649 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56650 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56651 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56652 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56653 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56654 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56655 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56656 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56657 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56658 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56659 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56660 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56661 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56662 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56663 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56664 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56665 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56666 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56667 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56668 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56669 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56670 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56671 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56672 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56673 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56674 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56675 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56676 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56677 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56678 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56679 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56680 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56681
56682 // Initialize threading, some globals and such
56683 __wxPyPreStart(d);
56684
56685
56686 // Although these are defined in __version__ they need to be here too so
56687 // that an assert can be done to ensure that the wxPython and the wxWindows
56688 // versions match.
56689 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56690 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56691 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56692
56693 }
56694
wxWidgets (Impactor)